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/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441
 442 #include <dali/devel-api/images/nine-patch-image.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 457 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 472
 473
 474 // add here SWIG version check
 475
 476 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 477 // disable Swig-dependent warnings
 478
 479 // 'identifier1' has C-linkage specified,
 480 // but returns UDT 'identifier2' which is incompatible with C
 481 #pragma warning(disable: 4190)
 482
 483 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 484 #pragma warning(disable: 4800)
 485
 486 // debug info too long etc etc
 487 #pragma warning(disable: 4786)
 488 #endif
 489
 490
 491 #include <stdexcept>
 492
 493
 494 #include <string>
 495
 496
 497 #include <vector>
 498 #include <algorithm>
 499 #include <stdexcept>
 500
 501
 502 #include <map>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <utility>
 508
 509
 510 typedef float floatp;
 511
 512 SWIGINTERN floatp *new_floatp(){
 513   return new float();
 514 }
 515 SWIGINTERN void delete_floatp(floatp *self){
 516   if (self) delete self;
 517 }
 518 SWIGINTERN void floatp_assign(floatp *self,float value){
 519   *self = value;
 520 }
 521 SWIGINTERN float floatp_value(floatp *self){
 522   return *self;
 523 }
 524 SWIGINTERN float *floatp_cast(floatp *self){
 525   return self;
 526 }
 527 SWIGINTERN floatp *floatp_frompointer(float *t){
 528   return (floatp *) t;
 529 }
 530
 531 typedef int intp;
 532
 533 SWIGINTERN intp *new_intp(){
 534   return new int();
 535 }
 536 SWIGINTERN void delete_intp(intp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void intp_assign(intp *self,int value){
 540   *self = value;
 541 }
 542 SWIGINTERN int intp_value(intp *self){
 543   return *self;
 544 }
 545 SWIGINTERN int *intp_cast(intp *self){
 546   return self;
 547 }
 548 SWIGINTERN intp *intp_frompointer(int *t){
 549   return (intp *) t;
 550 }
 551
 552 typedef double doublep;
 553
 554 SWIGINTERN doublep *new_doublep(){
 555   return new double();
 556 }
 557 SWIGINTERN void delete_doublep(doublep *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void doublep_assign(doublep *self,double value){
 561   *self = value;
 562 }
 563 SWIGINTERN double doublep_value(doublep *self){
 564   return *self;
 565 }
 566 SWIGINTERN double *doublep_cast(doublep *self){
 567   return self;
 568 }
 569 SWIGINTERN doublep *doublep_frompointer(double *t){
 570   return (doublep *) t;
 571 }
 572
 573 typedef unsigned int uintp;
 574
 575 SWIGINTERN uintp *new_uintp(){
 576   return new unsigned int();
 577 }
 578 SWIGINTERN void delete_uintp(uintp *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 582   *self = value;
 583 }
 584 SWIGINTERN unsigned int uintp_value(uintp *self){
 585   return *self;
 586 }
 587 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 588   return self;
 589 }
 590 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 591   return (uintp *) t;
 592 }
 593
 594 typedef unsigned short ushortp;
 595
 596 SWIGINTERN ushortp *new_ushortp(){
 597   return new unsigned short();
 598 }
 599 SWIGINTERN void delete_ushortp(ushortp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 609   return self;
 610 }
 611 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 612   return (ushortp *) t;
 613 }
 614
 615 unsigned int int_to_uint(int x) {
 616    return (unsigned int) x;
 617 }
 618
 619
 620 using namespace Dali;
 621 using namespace Dali::Toolkit;
 622
 623 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 624
 625      // C++ code. DALi uses Handle <-> Body design pattern.
 626      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 627      // Handles in DALi can be converted into a boolean type
 628      // to check if the handle has a valid body attached to it.
 629      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 630      if( *self )
 631      {
 632        return true;
 633      }
 634      else
 635      {
 636        return false;
 637      }
 638     }
 639 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 640
 641      // C++ code. Check if two handles reference the same implemtion
 642      if( *self == rhs)
 643      {
 644        return true;
 645      }
 646      else
 647      {
 648        return false;
 649      }
 650     }
 651 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 652      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 653    }
 654 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){
 655      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 656    }
 657 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 658         std::vector< Dali::TouchPoint >* pv = 0;
 659         if (capacity >= 0) {
 660           pv = new std::vector< Dali::TouchPoint >();
 661           pv->reserve(capacity);
 662        } else {
 663           throw std::out_of_range("capacity");
 664        }
 665        return pv;
 666       }
 667 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 668         if (index>=0 && index<(int)self->size())
 669           return (*self)[index];
 670         else
 671           throw std::out_of_range("index");
 672       }
 673 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 674         if (index>=0 && index<(int)self->size())
 675           return (*self)[index];
 676         else
 677           throw std::out_of_range("index");
 678       }
 679 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 680         if (index>=0 && index<(int)self->size())
 681           (*self)[index] = val;
 682         else
 683           throw std::out_of_range("index");
 684       }
 685 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 686         self->insert(self->end(), values.begin(), values.end());
 687       }
 688 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 689         if (index < 0)
 690           throw std::out_of_range("index");
 691         if (count < 0)
 692           throw std::out_of_range("count");
 693         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 694           throw std::invalid_argument("invalid range");
 695         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 696       }
 697 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 698         if (index>=0 && index<(int)self->size()+1)
 699           self->insert(self->begin()+index, x);
 700         else
 701           throw std::out_of_range("index");
 702       }
 703 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 704         if (index>=0 && index<(int)self->size()+1)
 705           self->insert(self->begin()+index, values.begin(), values.end());
 706         else
 707           throw std::out_of_range("index");
 708       }
 709 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 710         if (index>=0 && index<(int)self->size())
 711           self->erase(self->begin() + index);
 712         else
 713           throw std::out_of_range("index");
 714       }
 715 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 716         if (index < 0)
 717           throw std::out_of_range("index");
 718         if (count < 0)
 719           throw std::out_of_range("count");
 720         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 721           throw std::invalid_argument("invalid range");
 722         self->erase(self->begin()+index, self->begin()+index+count);
 723       }
 724 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 725         if (count < 0)
 726           throw std::out_of_range("count");
 727         return new std::vector< Dali::TouchPoint >(count, value);
 728       }
 729 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 730         std::reverse(self->begin(), self->end());
 731       }
 732 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 733         if (index < 0)
 734           throw std::out_of_range("index");
 735         if (count < 0)
 736           throw std::out_of_range("count");
 737         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 738           throw std::invalid_argument("invalid range");
 739         std::reverse(self->begin()+index, self->begin()+index+count);
 740       }
 741 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 742         if (index < 0)
 743           throw std::out_of_range("index");
 744         if (index+values.size() > self->size())
 745           throw std::out_of_range("index");
 746         std::copy(values.begin(), values.end(), self->begin()+index);
 747       }
 748 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 749          return self->Empty();
 750       }
 751 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 752         return self->GetConnectionCount();
 753       }
 754 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 755           self->Connect( func );
 756       }
 757 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 758           self->Disconnect( func );
 759       }
 760 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 761           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 762 /*@SWIG@*/ self->Emit( arg );
 763       }
 764 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 765          return self->Empty();
 766       }
 767 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 768         return self->GetConnectionCount();
 769       }
 770 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 771           self->Connect( func );
 772       }
 773 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 774           self->Disconnect( func );
 775       }
 776 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 777           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 778 /*@SWIG@*/ self->Emit( arg );
 779       }
 780 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 781          return self->Empty();
 782       }
 783 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){
 784         return self->GetConnectionCount();
 785       }
 786 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 *)){
 787           self->Connect( func );
 788       }
 789 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 *)){
 790           self->Disconnect( func );
 791       }
 792 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){
 793           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 794 /*@SWIG@*/ self->Emit( arg );
 795       }
 796 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 797          return self->Empty();
 798       }
 799 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 800         return self->GetConnectionCount();
 801       }
 802 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 803           self->Connect( func );
 804       }
 805 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 806           self->Disconnect( func );
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 809           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 810 /*@SWIG@*/ self->Emit( arg );
 811       }
 812 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 813          return self->Empty();
 814       }
 815 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 816         return self->GetConnectionCount();
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 819           self->Connect( func );
 820       }
 821 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 822           self->Disconnect( func );
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 825           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 826 /*@SWIG@*/ self->Emit( arg );
 827       }
 828 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){
 829          return self->Empty();
 830       }
 831 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){
 832         return self->GetConnectionCount();
 833       }
 834 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 &)){
 835         self->Connect( func );
 836       }
 837 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 &)){
 838         self->Disconnect( func );
 839       }
 840 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){
 841         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 842 /*@SWIG@*/ self->Emit( arg1, arg2 );
 843       }
 844 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){
 845          return self->Empty();
 846       }
 847 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){
 848         return self->GetConnectionCount();
 849       }
 850 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 &)){
 851         self->Connect( func );
 852       }
 853 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 &)){
 854         self->Disconnect( func );
 855       }
 856 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){
 857         return self->Emit( arg1, arg2 );
 858       }
 859 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){
 860          return self->Empty();
 861       }
 862 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){
 863         return self->GetConnectionCount();
 864       }
 865 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 &)){
 866         self->Connect( func );
 867       }
 868 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 &)){
 869         self->Disconnect( func );
 870       }
 871 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){
 872         return self->Emit( arg1, arg2 );
 873       }
 874 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){
 875          return self->Empty();
 876       }
 877 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){
 878         return self->GetConnectionCount();
 879       }
 880 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 &)){
 881         self->Connect( func );
 882       }
 883 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 &)){
 884         self->Disconnect( func );
 885       }
 886 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){
 887         return self->Emit( arg1, arg2 );
 888       }
 889 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 890          return self->Empty();
 891       }
 892 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 893         return self->GetConnectionCount();
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 896           self->Connect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 899           self->Disconnect( func );
 900       }
 901 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 902           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 903 /*@SWIG@*/ self->Emit( arg );
 904       }
 905 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 906          return self->Empty();
 907       }
 908 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){
 909         return self->GetConnectionCount();
 910       }
 911 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 &)){
 912           self->Connect( func );
 913       }
 914 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 &)){
 915           self->Disconnect( func );
 916       }
 917 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){
 918           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 919 /*@SWIG@*/ self->Emit( arg );
 920       }
 921 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 922          return self->Empty();
 923       }
 924 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){
 925         return self->GetConnectionCount();
 926       }
 927 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 &)){
 928           self->Connect( func );
 929       }
 930 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 &)){
 931           self->Disconnect( func );
 932       }
 933 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){
 934           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 935 /*@SWIG@*/ self->Emit( arg );
 936       }
 937 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 938          return self->Empty();
 939       }
 940 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){
 941         return self->GetConnectionCount();
 942       }
 943 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 &)){
 944           self->Connect( func );
 945       }
 946 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 &)){
 947           self->Disconnect( func );
 948       }
 949 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){
 950           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 951 /*@SWIG@*/ self->Emit( arg );
 952       }
 953 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){
 954          return self->Empty();
 955       }
 956 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){
 957         return self->GetConnectionCount();
 958       }
 959 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 &)){
 960         self->Connect( func );
 961       }
 962 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 &)){
 963         self->Disconnect( func );
 964       }
 965 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){
 966         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 967 /*@SWIG@*/ self->Emit( arg1, arg2 );
 968       }
 969 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){
 970          return self->Empty();
 971       }
 972 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){
 973         return self->GetConnectionCount();
 974       }
 975 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 &)){
 976         self->Connect( func );
 977       }
 978 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 &)){
 979         self->Disconnect( func );
 980       }
 981 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){
 982         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 983 /*@SWIG@*/ self->Emit( arg1, arg2 );
 984       }
 985 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){
 986          return self->Empty();
 987       }
 988 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){
 989         return self->GetConnectionCount();
 990       }
 991 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 &)){
 992         self->Connect( func );
 993       }
 994 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 &)){
 995         self->Disconnect( func );
 996       }
 997 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){
 998         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 999 /*@SWIG@*/ self->Emit( arg1, arg2 );
1000       }
1001 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1002          return self->Empty();
1003       }
1004 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1005         return self->GetConnectionCount();
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1008           self->Connect( func );
1009       }
1010 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1011           self->Disconnect( func );
1012       }
1013 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1014           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1015 /*@SWIG@*/ self->Emit( arg );
1016       }
1017 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1018          return self->Empty();
1019       }
1020 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1021         return self->GetConnectionCount();
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1024           self->Connect( func );
1025       }
1026 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1027           self->Disconnect( func );
1028       }
1029 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1030           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1031 /*@SWIG@*/ self->Emit( arg );
1032       }
1033 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){
1034          return self->Empty();
1035       }
1036 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){
1037         return self->GetConnectionCount();
1038       }
1039 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)){
1040           return self->Connect( func );
1041       }
1042 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)){
1043           self->Disconnect( func );
1044       }
1045 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){
1046           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1047 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1048       }
1049
1050 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1051          return self->Empty();
1052       }
1053 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1054         return self->GetConnectionCount();
1055       }
1056 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1057           self->Connect( func );
1058       }
1059 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1060           self->Disconnect( func );
1061       }
1062 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1063           return self->Emit();
1064       }
1065
1066 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1067         std::vector< unsigned int >* pv = 0;
1068         if (capacity >= 0) {
1069           pv = new std::vector< unsigned int >();
1070           pv->reserve(capacity);
1071        } else {
1072           throw std::out_of_range("capacity");
1073        }
1074        return pv;
1075       }
1076 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1077         if (index>=0 && index<(int)self->size())
1078           return (*self)[index];
1079         else
1080           throw std::out_of_range("index");
1081       }
1082 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1083         if (index>=0 && index<(int)self->size())
1084           return (*self)[index];
1085         else
1086           throw std::out_of_range("index");
1087       }
1088 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1089         if (index>=0 && index<(int)self->size())
1090           (*self)[index] = val;
1091         else
1092           throw std::out_of_range("index");
1093       }
1094 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1095         self->insert(self->end(), values.begin(), values.end());
1096       }
1097 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1098         if (index < 0)
1099           throw std::out_of_range("index");
1100         if (count < 0)
1101           throw std::out_of_range("count");
1102         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1103           throw std::invalid_argument("invalid range");
1104         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1105       }
1106 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1107         if (index>=0 && index<(int)self->size()+1)
1108           self->insert(self->begin()+index, x);
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1113         if (index>=0 && index<(int)self->size()+1)
1114           self->insert(self->begin()+index, values.begin(), values.end());
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1119         if (index>=0 && index<(int)self->size())
1120           self->erase(self->begin() + index);
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1125         if (index < 0)
1126           throw std::out_of_range("index");
1127         if (count < 0)
1128           throw std::out_of_range("count");
1129         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1130           throw std::invalid_argument("invalid range");
1131         self->erase(self->begin()+index, self->begin()+index+count);
1132       }
1133 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1134         if (count < 0)
1135           throw std::out_of_range("count");
1136         return new std::vector< unsigned int >(count, value);
1137       }
1138 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1139         std::reverse(self->begin(), self->end());
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1142         if (index < 0)
1143           throw std::out_of_range("index");
1144         if (count < 0)
1145           throw std::out_of_range("count");
1146         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1147           throw std::invalid_argument("invalid range");
1148         std::reverse(self->begin()+index, self->begin()+index+count);
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1151         if (index < 0)
1152           throw std::out_of_range("index");
1153         if (index+values.size() > self->size())
1154           throw std::out_of_range("index");
1155         std::copy(values.begin(), values.end(), self->begin()+index);
1156       }
1157 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1158         return std::find(self->begin(), self->end(), value) != self->end();
1159       }
1160 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1161         int index = -1;
1162         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1163         if (it != self->end())
1164           index = (int)(it - self->begin());
1165         return index;
1166       }
1167 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1168         int index = -1;
1169         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1170         if (rit != self->rend())
1171           index = (int)(self->rend() - 1 - rit);
1172         return index;
1173       }
1174 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1175         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1176         if (it != self->end()) {
1177           self->erase(it);
1178           return true;
1179         }
1180         return false;
1181       }
1182 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){
1183         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1184         if (capacity >= 0) {
1185           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1186           pv->reserve(capacity);
1187        } else {
1188           throw std::out_of_range("capacity");
1189        }
1190        return pv;
1191       }
1192 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){
1193         if (index>=0 && index<(int)self->size())
1194           return (*self)[index];
1195         else
1196           throw std::out_of_range("index");
1197       }
1198 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){
1199         if (index>=0 && index<(int)self->size())
1200           return (*self)[index];
1201         else
1202           throw std::out_of_range("index");
1203       }
1204 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){
1205         if (index>=0 && index<(int)self->size())
1206           (*self)[index] = val;
1207         else
1208           throw std::out_of_range("index");
1209       }
1210 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){
1211         self->insert(self->end(), values.begin(), values.end());
1212       }
1213 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){
1214         if (index < 0)
1215           throw std::out_of_range("index");
1216         if (count < 0)
1217           throw std::out_of_range("count");
1218         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1219           throw std::invalid_argument("invalid range");
1220         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1221       }
1222 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){
1223         if (index>=0 && index<(int)self->size()+1)
1224           self->insert(self->begin()+index, x);
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 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){
1229         if (index>=0 && index<(int)self->size()+1)
1230           self->insert(self->begin()+index, values.begin(), values.end());
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 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){
1235         if (index>=0 && index<(int)self->size())
1236           self->erase(self->begin() + index);
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 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){
1241         if (index < 0)
1242           throw std::out_of_range("index");
1243         if (count < 0)
1244           throw std::out_of_range("count");
1245         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1246           throw std::invalid_argument("invalid range");
1247         self->erase(self->begin()+index, self->begin()+index+count);
1248       }
1249 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){
1250         if (count < 0)
1251           throw std::out_of_range("count");
1252         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1253       }
1254 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){
1255         std::reverse(self->begin(), self->end());
1256       }
1257 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){
1258         if (index < 0)
1259           throw std::out_of_range("index");
1260         if (count < 0)
1261           throw std::out_of_range("count");
1262         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1263           throw std::invalid_argument("invalid range");
1264         std::reverse(self->begin()+index, self->begin()+index+count);
1265       }
1266 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){
1267         if (index < 0)
1268           throw std::out_of_range("index");
1269         if (index+values.size() > self->size())
1270           throw std::out_of_range("index");
1271         std::copy(values.begin(), values.end(), self->begin()+index);
1272       }
1273 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1274         std::vector< Dali::Actor >* pv = 0;
1275         if (capacity >= 0) {
1276           pv = new std::vector< Dali::Actor >();
1277           pv->reserve(capacity);
1278        } else {
1279           throw std::out_of_range("capacity");
1280        }
1281        return pv;
1282       }
1283 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1284         if (index>=0 && index<(int)self->size())
1285           return (*self)[index];
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1290         if (index>=0 && index<(int)self->size())
1291           return (*self)[index];
1292         else
1293           throw std::out_of_range("index");
1294       }
1295 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1296         if (index>=0 && index<(int)self->size())
1297           (*self)[index] = val;
1298         else
1299           throw std::out_of_range("index");
1300       }
1301 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1302         self->insert(self->end(), values.begin(), values.end());
1303       }
1304 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1305         if (index < 0)
1306           throw std::out_of_range("index");
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1310           throw std::invalid_argument("invalid range");
1311         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1312       }
1313 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1314         if (index>=0 && index<(int)self->size()+1)
1315           self->insert(self->begin()+index, x);
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1320         if (index>=0 && index<(int)self->size()+1)
1321           self->insert(self->begin()+index, values.begin(), values.end());
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1326         if (index>=0 && index<(int)self->size())
1327           self->erase(self->begin() + index);
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1332         if (index < 0)
1333           throw std::out_of_range("index");
1334         if (count < 0)
1335           throw std::out_of_range("count");
1336         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1337           throw std::invalid_argument("invalid range");
1338         self->erase(self->begin()+index, self->begin()+index+count);
1339       }
1340 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1341         if (count < 0)
1342           throw std::out_of_range("count");
1343         return new std::vector< Dali::Actor >(count, value);
1344       }
1345 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1346         std::reverse(self->begin(), self->end());
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1349         if (index < 0)
1350           throw std::out_of_range("index");
1351         if (count < 0)
1352           throw std::out_of_range("count");
1353         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1354           throw std::invalid_argument("invalid range");
1355         std::reverse(self->begin()+index, self->begin()+index+count);
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1358         if (index < 0)
1359           throw std::out_of_range("index");
1360         if (index+values.size() > self->size())
1361           throw std::out_of_range("index");
1362         std::copy(values.begin(), values.end(), self->begin()+index);
1363       }
1364 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1365          return self->Empty();
1366       }
1367 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1368         return self->GetConnectionCount();
1369       }
1370 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 &)){
1371           self->Connect( func );
1372       }
1373 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 &)){
1374           self->Disconnect( func );
1375       }
1376 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){
1377           return self->Emit( arg );
1378       }
1379 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){
1380          return self->Empty();
1381       }
1382 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){
1383         return self->GetConnectionCount();
1384       }
1385 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)){
1386         self->Connect( func );
1387       }
1388 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)){
1389         self->Disconnect( func );
1390       }
1391 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){
1392         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1393 /*@SWIG@*/ self->Emit( arg1, arg2 );
1394       }
1395 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1396          return self->Empty();
1397       }
1398 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){
1399         return self->GetConnectionCount();
1400       }
1401 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)){
1402         self->Connect( func );
1403       }
1404 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)){
1405         self->Disconnect( func );
1406       }
1407 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){
1408         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1409 /*@SWIG@*/ self->Emit( arg1, arg2 );
1410       }
1411 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1412          return self->Empty();
1413       }
1414 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1415         return self->GetConnectionCount();
1416       }
1417 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)){
1418         self->Connect( func );
1419       }
1420 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)){
1421         self->Disconnect( func );
1422       }
1423 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){
1424         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1425 /*@SWIG@*/ self->Emit( arg1, arg2 );
1426       }
1427 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){
1428          return self->Empty();
1429       }
1430 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){
1431         return self->GetConnectionCount();
1432       }
1433 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)){
1434         self->Connect( func );
1435       }
1436 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)){
1437         self->Disconnect( func );
1438       }
1439 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){
1440         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1441 /*@SWIG@*/ self->Emit( arg1, arg2 );
1442       }
1443 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1444          return self->Empty();
1445       }
1446 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1447         return self->GetConnectionCount();
1448       }
1449 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)){
1450           self->Connect( func );
1451       }
1452 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)){
1453           self->Disconnect( func );
1454       }
1455 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1456           return self->Emit( arg );
1457       }
1458 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1459          return self->Empty();
1460       }
1461 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1462         return self->GetConnectionCount();
1463       }
1464 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)){
1465           self->Connect( func );
1466       }
1467 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)){
1468           self->Disconnect( func );
1469       }
1470 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1471           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1472 /*@SWIG@*/ self->Emit( arg );
1473       }
1474 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){
1475          return self->Empty();
1476       }
1477 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){
1478         return self->GetConnectionCount();
1479       }
1480 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)){
1481           return self->Connect( func );
1482       }
1483 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)){
1484           self->Disconnect( func );
1485       }
1486 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){
1487           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1488 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1489       }
1490 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1491          return self->Empty();
1492       }
1493 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1494         return self->GetConnectionCount();
1495       }
1496 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)){
1497           self->Connect( func );
1498       }
1499 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)){
1500           self->Disconnect( func );
1501       }
1502 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1503           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1504 /*@SWIG@*/ self->Emit( arg );
1505       }
1506 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){
1507          return self->Empty();
1508       }
1509 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){
1510         return self->GetConnectionCount();
1511       }
1512 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)){
1513           return self->Connect( func );
1514       }
1515 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)){
1516           self->Disconnect( func );
1517       }
1518 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){
1519           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1520 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1521       }
1522 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){
1523          return self->Empty();
1524       }
1525 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){
1526         return self->GetConnectionCount();
1527       }
1528 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 &)){
1529           self->Connect( func );
1530       }
1531 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 &)){
1532           self->Disconnect( func );
1533       }
1534 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){
1535           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1536 /*@SWIG@*/ self->Emit( arg );
1537       }
1538 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1539          return self->Empty();
1540       }
1541 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){
1542         return self->GetConnectionCount();
1543       }
1544 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 &)){
1545           self->Connect( func );
1546       }
1547 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 &)){
1548           self->Disconnect( func );
1549       }
1550 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){
1551           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1552 /*@SWIG@*/ self->Emit( arg );
1553       }
1554
1555
1556 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){
1557          return self->Empty();
1558       }
1559 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){
1560         return self->GetConnectionCount();
1561       }
1562 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 &)){
1563         self->Connect( func );
1564       }
1565 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 &)){
1566         self->Disconnect( func );
1567       }
1568 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){
1569         return self->Emit( arg1, arg2 );
1570       }
1571 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1572          return self->Empty();
1573       }
1574 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1575         return self->GetConnectionCount();
1576       }
1577 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)){
1578           self->Connect( func );
1579       }
1580 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)){
1581           self->Disconnect( func );
1582       }
1583 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1584           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1585 /*@SWIG@*/ self->Emit( arg );
1586       }
1587 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1588          return self->Empty();
1589       }
1590 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1591         return self->GetConnectionCount();
1592       }
1593 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 &)){
1594           self->Connect( func );
1595       }
1596 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 &)){
1597           self->Disconnect( func );
1598       }
1599 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){
1600           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1601 /*@SWIG@*/ self->Emit( arg );
1602       }
1603 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1604          return self->Empty();
1605       }
1606 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){
1607         return self->GetConnectionCount();
1608       }
1609 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)){
1610         self->Connect( func );
1611       }
1612 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)){
1613         self->Disconnect( func );
1614       }
1615 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){
1616         return self->Emit( arg1, arg2 );
1617       }
1618 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1619          return self->Empty();
1620       }
1621 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){
1622         return self->GetConnectionCount();
1623       }
1624 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)){
1625         self->Connect( func );
1626       }
1627 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)){
1628         self->Disconnect( func );
1629       }
1630 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){
1631         return self->Emit( arg1, arg2 );
1632       }
1633
1634
1635 /* ---------------------------------------------------
1636  * C++ director class methods
1637  * --------------------------------------------------- */
1638
1639 #include "dali_wrap.h"
1640
1641 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1642   swig_init_callbacks();
1643 }
1644
1645 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1646
1647 }
1648
1649
1650 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1651   int jdepth  ;
1652
1653   if (!swig_callbackOnStageConnection) {
1654     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1655     return;
1656   } else {
1657     jdepth = depth;
1658     swig_callbackOnStageConnection(jdepth);
1659   }
1660 }
1661
1662 void SwigDirector_ViewImpl::OnStageDisconnection() {
1663   if (!swig_callbackOnStageDisconnection) {
1664     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1665     return;
1666   } else {
1667     swig_callbackOnStageDisconnection();
1668   }
1669 }
1670
1671 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1672   void * jchild = 0 ;
1673
1674   if (!swig_callbackOnChildAdd) {
1675     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1676     return;
1677   } else {
1678     jchild = (Dali::Actor *) &child;
1679     swig_callbackOnChildAdd(jchild);
1680   }
1681 }
1682
1683 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1684   void * jchild = 0 ;
1685
1686   if (!swig_callbackOnChildRemove) {
1687     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1688     return;
1689   } else {
1690     jchild = (Dali::Actor *) &child;
1691     swig_callbackOnChildRemove(jchild);
1692   }
1693 }
1694
1695 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1696   int jindex  ;
1697   void * jpropertyValue  ;
1698
1699   if (!swig_callbackOnPropertySet) {
1700     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1701     return;
1702   } else {
1703     jindex = index;
1704     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1705     swig_callbackOnPropertySet(jindex, jpropertyValue);
1706   }
1707 }
1708
1709 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1710   void * jtargetSize = 0 ;
1711
1712   if (!swig_callbackOnSizeSet) {
1713     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1714     return;
1715   } else {
1716     jtargetSize = (Dali::Vector3 *) &targetSize;
1717     swig_callbackOnSizeSet(jtargetSize);
1718   }
1719 }
1720
1721 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1722   void * janimation = 0 ;
1723   void * jtargetSize = 0 ;
1724
1725   if (!swig_callbackOnSizeAnimation) {
1726     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1727     return;
1728   } else {
1729     janimation = (Dali::Animation *) &animation;
1730     jtargetSize = (Dali::Vector3 *) &targetSize;
1731     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1732   }
1733 }
1734
1735 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1736   bool c_result = SwigValueInit< bool >() ;
1737   unsigned int jresult = 0 ;
1738   void * jarg0 = 0 ;
1739
1740   if (!swig_callbackOnTouchEvent) {
1741     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1742   } else {
1743     jarg0 = (Dali::TouchEvent *) &event;
1744     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1745     c_result = jresult ? true : false;
1746   }
1747   return c_result;
1748 }
1749
1750 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1751   bool c_result = SwigValueInit< bool >() ;
1752   unsigned int jresult = 0 ;
1753   void * jarg0 = 0 ;
1754
1755   if (!swig_callbackOnHoverEvent) {
1756     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1757   } else {
1758     jarg0 = (Dali::HoverEvent *) &event;
1759     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1760     c_result = jresult ? true : false;
1761   }
1762   return c_result;
1763 }
1764
1765 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1766   bool c_result = SwigValueInit< bool >() ;
1767   unsigned int jresult = 0 ;
1768   void * jarg0 = 0 ;
1769
1770   if (!swig_callbackOnKeyEvent) {
1771     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1772   } else {
1773     jarg0 = (Dali::KeyEvent *) &event;
1774     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1775     c_result = jresult ? true : false;
1776   }
1777   return c_result;
1778 }
1779
1780 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1781   bool c_result = SwigValueInit< bool >() ;
1782   unsigned int jresult = 0 ;
1783   void * jarg0 = 0 ;
1784
1785   if (!swig_callbackOnWheelEvent) {
1786     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1787   } else {
1788     jarg0 = (Dali::WheelEvent *) &event;
1789     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1790     c_result = jresult ? true : false;
1791   }
1792   return c_result;
1793 }
1794
1795 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1796   void * jsize = 0 ;
1797   void * jcontainer = 0 ;
1798
1799   if (!swig_callbackOnRelayout) {
1800     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1801     return;
1802   } else {
1803     jsize = (Dali::Vector2 *) &size;
1804     jcontainer = (Dali::RelayoutContainer *) &container;
1805     swig_callbackOnRelayout(jsize, jcontainer);
1806   }
1807 }
1808
1809 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1810   int jpolicy  ;
1811   int jdimension  ;
1812
1813   if (!swig_callbackOnSetResizePolicy) {
1814     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1815     return;
1816   } else {
1817     jpolicy = (int)policy;
1818     jdimension = (int)dimension;
1819     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1820   }
1821 }
1822
1823 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1824   Dali::Vector3 c_result ;
1825   void * jresult = 0 ;
1826
1827   if (!swig_callbackGetNaturalSize) {
1828     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1829   } else {
1830     jresult = (void *) swig_callbackGetNaturalSize();
1831     if (!jresult) {
1832       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1833       return c_result;
1834     }
1835     c_result = *(Dali::Vector3 *)jresult;
1836   }
1837   return c_result;
1838 }
1839
1840 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1841   float c_result = SwigValueInit< float >() ;
1842   float jresult = 0 ;
1843   void * jchild = 0 ;
1844   int jdimension  ;
1845
1846   if (!swig_callbackCalculateChildSize) {
1847     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1848   } else {
1849     jchild = (Dali::Actor *) &child;
1850     jdimension = (int)dimension;
1851     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1852     c_result = (float)jresult;
1853   }
1854   return c_result;
1855 }
1856
1857 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1858   float c_result = SwigValueInit< float >() ;
1859   float jresult = 0 ;
1860   float jwidth  ;
1861
1862   if (!swig_callbackGetHeightForWidth) {
1863     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1864   } else {
1865     jwidth = width;
1866     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1867     c_result = (float)jresult;
1868   }
1869   return c_result;
1870 }
1871
1872 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1873   float c_result = SwigValueInit< float >() ;
1874   float jresult = 0 ;
1875   float jheight  ;
1876
1877   if (!swig_callbackGetWidthForHeight) {
1878     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1879   } else {
1880     jheight = height;
1881     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1882     c_result = (float)jresult;
1883   }
1884   return c_result;
1885 }
1886
1887 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1888   bool c_result = SwigValueInit< bool >() ;
1889   unsigned int jresult = 0 ;
1890   int jdimension  ;
1891
1892   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1893     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1894   } else {
1895     jdimension = (int)dimension;
1896     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1897     c_result = jresult ? true : false;
1898   }
1899   return c_result;
1900 }
1901
1902 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1903   int jdimension  ;
1904
1905   if (!swig_callbackOnCalculateRelayoutSize) {
1906     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1907     return;
1908   } else {
1909     jdimension = (int)dimension;
1910     swig_callbackOnCalculateRelayoutSize(jdimension);
1911   }
1912 }
1913
1914 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1915   float jsize  ;
1916   int jdimension  ;
1917
1918   if (!swig_callbackOnLayoutNegotiated) {
1919     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1920     return;
1921   } else {
1922     jsize = size;
1923     jdimension = (int)dimension;
1924     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1925   }
1926 }
1927
1928 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1929   return Dali::CustomActorImpl::GetExtension();
1930 }
1931
1932 void SwigDirector_ViewImpl::OnInitialize() {
1933   if (!swig_callbackOnInitialize) {
1934     Dali::Toolkit::Internal::Control::OnInitialize();
1935     return;
1936   } else {
1937     swig_callbackOnInitialize();
1938   }
1939 }
1940
1941 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1942   void * jchild = 0 ;
1943
1944   if (!swig_callbackOnControlChildAdd) {
1945     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1946     return;
1947   } else {
1948     jchild = (Dali::Actor *) &child;
1949     swig_callbackOnControlChildAdd(jchild);
1950   }
1951 }
1952
1953 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1954   void * jchild = 0 ;
1955
1956   if (!swig_callbackOnControlChildRemove) {
1957     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1958     return;
1959   } else {
1960     jchild = (Dali::Actor *) &child;
1961     swig_callbackOnControlChildRemove(jchild);
1962   }
1963 }
1964
1965 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1966   void * jstyleManager  ;
1967   int jchange  ;
1968
1969   if (!swig_callbackOnStyleChange) {
1970     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1971     return;
1972   } else {
1973     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1974     jchange = (int)change;
1975     swig_callbackOnStyleChange(jstyleManager, jchange);
1976   }
1977 }
1978
1979 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1980   bool c_result = SwigValueInit< bool >() ;
1981   unsigned int jresult = 0 ;
1982
1983   if (!swig_callbackOnAccessibilityActivated) {
1984     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1985   } else {
1986     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1987     c_result = jresult ? true : false;
1988   }
1989   return c_result;
1990 }
1991
1992 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1993   bool c_result = SwigValueInit< bool >() ;
1994   unsigned int jresult = 0 ;
1995   void * jgesture  ;
1996
1997   if (!swig_callbackOnAccessibilityPan) {
1998     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1999   } else {
2000     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2001     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2002     c_result = jresult ? true : false;
2003   }
2004   return c_result;
2005 }
2006
2007 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2008   bool c_result = SwigValueInit< bool >() ;
2009   unsigned int jresult = 0 ;
2010   void * jtouchEvent = 0 ;
2011
2012   if (!swig_callbackOnAccessibilityTouch) {
2013     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2014   } else {
2015     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2016     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2017     c_result = jresult ? true : false;
2018   }
2019   return c_result;
2020 }
2021
2022 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2023   bool c_result = SwigValueInit< bool >() ;
2024   unsigned int jresult = 0 ;
2025   unsigned int jisIncrease  ;
2026
2027   if (!swig_callbackOnAccessibilityValueChange) {
2028     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2029   } else {
2030     jisIncrease = isIncrease;
2031     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2032     c_result = jresult ? true : false;
2033   }
2034   return c_result;
2035 }
2036
2037 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2038   bool c_result = SwigValueInit< bool >() ;
2039   unsigned int jresult = 0 ;
2040
2041   if (!swig_callbackOnAccessibilityZoom) {
2042     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2043   } else {
2044     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2045     c_result = jresult ? true : false;
2046   }
2047   return c_result;
2048 }
2049
2050 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2051   if (!swig_callbackOnKeyInputFocusGained) {
2052     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2053     return;
2054   } else {
2055     swig_callbackOnKeyInputFocusGained();
2056   }
2057 }
2058
2059 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2060   if (!swig_callbackOnKeyInputFocusLost) {
2061     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2062     return;
2063   } else {
2064     swig_callbackOnKeyInputFocusLost();
2065   }
2066 }
2067
2068 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2069   Dali::Actor c_result ;
2070   void * jresult = 0 ;
2071   void * jcurrentFocusedActor  ;
2072   int jdirection  ;
2073   unsigned int jloopEnabled  ;
2074
2075   if (!swig_callbackGetNextKeyboardFocusableActor) {
2076     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2077   } else {
2078     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2079     jdirection = (int)direction;
2080     jloopEnabled = loopEnabled;
2081     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2082     if (!jresult) {
2083       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2084       return c_result;
2085     }
2086     c_result = *(Dali::Actor *)jresult;
2087   }
2088   return c_result;
2089 }
2090
2091 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2092   void * jcommitedFocusableActor  ;
2093
2094   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2095     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2096     return;
2097   } else {
2098     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2099     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2100   }
2101 }
2102
2103 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2104   bool c_result = SwigValueInit< bool >() ;
2105   unsigned int jresult = 0 ;
2106
2107   if (!swig_callbackOnKeyboardEnter) {
2108     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2109   } else {
2110     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2111     c_result = jresult ? true : false;
2112   }
2113   return c_result;
2114 }
2115
2116 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2117   void * jpinch = 0 ;
2118
2119   if (!swig_callbackOnPinch) {
2120     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2121     return;
2122   } else {
2123     jpinch = (Dali::PinchGesture *) &pinch;
2124     swig_callbackOnPinch(jpinch);
2125   }
2126 }
2127
2128 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2129   void * jpan = 0 ;
2130
2131   if (!swig_callbackOnPan) {
2132     Dali::Toolkit::Internal::Control::OnPan(pan);
2133     return;
2134   } else {
2135     jpan = (Dali::PanGesture *) &pan;
2136     swig_callbackOnPan(jpan);
2137   }
2138 }
2139
2140 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2141   void * jtap = 0 ;
2142
2143   if (!swig_callbackOnTap) {
2144     Dali::Toolkit::Internal::Control::OnTap(tap);
2145     return;
2146   } else {
2147     jtap = (Dali::TapGesture *) &tap;
2148     swig_callbackOnTap(jtap);
2149   }
2150 }
2151
2152 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2153   void * jlongPress = 0 ;
2154
2155   if (!swig_callbackOnLongPress) {
2156     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2157     return;
2158   } else {
2159     jlongPress = (Dali::LongPressGesture *) &longPress;
2160     swig_callbackOnLongPress(jlongPress);
2161   }
2162 }
2163
2164 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2165   void * jslotObserver = 0 ;
2166   void * jcallback = 0 ;
2167
2168   if (!swig_callbackSignalConnected) {
2169     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2170     return;
2171   } else {
2172     jslotObserver = (void *) slotObserver;
2173     jcallback = (void *) callback;
2174     swig_callbackSignalConnected(jslotObserver, jcallback);
2175   }
2176 }
2177
2178 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2179   void * jslotObserver = 0 ;
2180   void * jcallback = 0 ;
2181
2182   if (!swig_callbackSignalDisconnected) {
2183     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2184     return;
2185   } else {
2186     jslotObserver = (void *) slotObserver;
2187     jcallback = (void *) callback;
2188     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2189   }
2190 }
2191
2192 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2193   return Dali::Toolkit::Internal::Control::GetControlExtension();
2194 }
2195
2196 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) {
2197   swig_callbackOnStageConnection = callbackOnStageConnection;
2198   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2199   swig_callbackOnChildAdd = callbackOnChildAdd;
2200   swig_callbackOnChildRemove = callbackOnChildRemove;
2201   swig_callbackOnPropertySet = callbackOnPropertySet;
2202   swig_callbackOnSizeSet = callbackOnSizeSet;
2203   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2204   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2205   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2206   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2207   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2208   swig_callbackOnRelayout = callbackOnRelayout;
2209   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2210   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2211   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2212   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2213   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2214   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2215   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2216   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2217   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2218   swig_callbackOnInitialize = callbackOnInitialize;
2219   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2220   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2221   swig_callbackOnStyleChange = callbackOnStyleChange;
2222   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2223   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2224   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2225   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2226   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2227   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2228   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2229   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2230   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2231   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2232   swig_callbackOnPinch = callbackOnPinch;
2233   swig_callbackOnPan = callbackOnPan;
2234   swig_callbackOnTap = callbackOnTap;
2235   swig_callbackOnLongPress = callbackOnLongPress;
2236   swig_callbackSignalConnected = callbackSignalConnected;
2237   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2238 }
2239
2240 void SwigDirector_ViewImpl::swig_init_callbacks() {
2241   swig_callbackOnStageConnection = 0;
2242   swig_callbackOnStageDisconnection = 0;
2243   swig_callbackOnChildAdd = 0;
2244   swig_callbackOnChildRemove = 0;
2245   swig_callbackOnPropertySet = 0;
2246   swig_callbackOnSizeSet = 0;
2247   swig_callbackOnSizeAnimation = 0;
2248   swig_callbackOnTouchEvent = 0;
2249   swig_callbackOnHoverEvent = 0;
2250   swig_callbackOnKeyEvent = 0;
2251   swig_callbackOnWheelEvent = 0;
2252   swig_callbackOnRelayout = 0;
2253   swig_callbackOnSetResizePolicy = 0;
2254   swig_callbackGetNaturalSize = 0;
2255   swig_callbackCalculateChildSize = 0;
2256   swig_callbackGetHeightForWidth = 0;
2257   swig_callbackGetWidthForHeight = 0;
2258   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2259   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2260   swig_callbackOnCalculateRelayoutSize = 0;
2261   swig_callbackOnLayoutNegotiated = 0;
2262   swig_callbackOnInitialize = 0;
2263   swig_callbackOnControlChildAdd = 0;
2264   swig_callbackOnControlChildRemove = 0;
2265   swig_callbackOnStyleChange = 0;
2266   swig_callbackOnAccessibilityActivated = 0;
2267   swig_callbackOnAccessibilityPan = 0;
2268   swig_callbackOnAccessibilityTouch = 0;
2269   swig_callbackOnAccessibilityValueChange = 0;
2270   swig_callbackOnAccessibilityZoom = 0;
2271   swig_callbackOnKeyInputFocusGained = 0;
2272   swig_callbackOnKeyInputFocusLost = 0;
2273   swig_callbackGetNextKeyboardFocusableActor = 0;
2274   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2275   swig_callbackOnKeyboardEnter = 0;
2276   swig_callbackOnPinch = 0;
2277   swig_callbackOnPan = 0;
2278   swig_callbackOnTap = 0;
2279   swig_callbackOnLongPress = 0;
2280   swig_callbackSignalConnected = 0;
2281   swig_callbackSignalDisconnected = 0;
2282 }
2283
2284 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2285   swig_init_callbacks();
2286 }
2287
2288 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2289
2290 }
2291
2292
2293 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2294   unsigned int c_result = SwigValueInit< unsigned int >() ;
2295   unsigned int jresult = 0 ;
2296
2297   if (!swig_callbackGetNumberOfItems) {
2298     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2299   } else {
2300     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2301     c_result = (unsigned int)jresult;
2302   }
2303   return c_result;
2304 }
2305
2306 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2307   Dali::Actor c_result ;
2308   void * jresult = 0 ;
2309   unsigned int jitemId  ;
2310
2311   if (!swig_callbackNewItem) {
2312     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2313   } else {
2314     jitemId = itemId;
2315     jresult = (void *) swig_callbackNewItem(jitemId);
2316     if (!jresult) {
2317       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2318       return c_result;
2319     }
2320     c_result = *(Dali::Actor *)jresult;
2321   }
2322   return c_result;
2323 }
2324
2325 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2326   unsigned int jitemId  ;
2327   void * jactor  ;
2328
2329   if (!swig_callbackItemReleased) {
2330     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2331     return;
2332   } else {
2333     jitemId = itemId;
2334     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2335     swig_callbackItemReleased(jitemId, jactor);
2336   }
2337 }
2338
2339 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2340   return Dali::Toolkit::ItemFactory::GetExtension();
2341 }
2342
2343 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2344   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2345   swig_callbackNewItem = callbackNewItem;
2346   swig_callbackItemReleased = callbackItemReleased;
2347 }
2348
2349 void SwigDirector_ItemFactory::swig_init_callbacks() {
2350   swig_callbackGetNumberOfItems = 0;
2351   swig_callbackNewItem = 0;
2352   swig_callbackItemReleased = 0;
2353 }
2354
2355 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2356   swig_init_callbacks();
2357 }
2358
2359 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2360
2361 }
2362
2363
2364 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2365   Dali::Actor c_result ;
2366   void * jresult = 0 ;
2367   void * jcurrent  ;
2368   void * jproposed  ;
2369   int jdirection  ;
2370
2371   if (!swig_callbackGetNextFocusableActor) {
2372     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2373   } else {
2374     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2375     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2376     jdirection = (int)direction;
2377     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2378     if (!jresult) {
2379       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2380       return c_result;
2381     }
2382     c_result = *(Dali::Actor *)jresult;
2383   }
2384   return c_result;
2385 }
2386
2387 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2388   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2389 }
2390
2391 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2392   swig_callbackGetNextFocusableActor = 0;
2393 }
2394
2395
2396 #ifdef __cplusplus
2397 extern "C" {
2398 #endif
2399
2400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2401   void * jresult ;
2402   floatp *result = 0 ;
2403
2404   {
2405     try {
2406       result = (floatp *)new_floatp();
2407     } catch (std::out_of_range& e) {
2408       {
2409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2410       };
2411     } catch (std::exception& e) {
2412       {
2413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2414       };
2415     } catch (...) {
2416       {
2417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2418       };
2419     }
2420   }
2421   jresult = (void *)result;
2422   return jresult;
2423 }
2424
2425
2426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2427   floatp *arg1 = (floatp *) 0 ;
2428
2429   arg1 = (floatp *)jarg1;
2430   {
2431     try {
2432       delete_floatp(arg1);
2433     } catch (std::out_of_range& e) {
2434       {
2435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2436       };
2437     } catch (std::exception& e) {
2438       {
2439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2440       };
2441     } catch (...) {
2442       {
2443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2444       };
2445     }
2446   }
2447 }
2448
2449
2450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2451   floatp *arg1 = (floatp *) 0 ;
2452   float arg2 ;
2453
2454   arg1 = (floatp *)jarg1;
2455   arg2 = (float)jarg2;
2456   {
2457     try {
2458       floatp_assign(arg1,arg2);
2459     } catch (std::out_of_range& e) {
2460       {
2461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2462       };
2463     } catch (std::exception& e) {
2464       {
2465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2466       };
2467     } catch (...) {
2468       {
2469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2470       };
2471     }
2472   }
2473 }
2474
2475
2476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2477   float jresult ;
2478   floatp *arg1 = (floatp *) 0 ;
2479   float result;
2480
2481   arg1 = (floatp *)jarg1;
2482   {
2483     try {
2484       result = (float)floatp_value(arg1);
2485     } catch (std::out_of_range& e) {
2486       {
2487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2488       };
2489     } catch (std::exception& e) {
2490       {
2491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2492       };
2493     } catch (...) {
2494       {
2495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2496       };
2497     }
2498   }
2499   jresult = result;
2500   return jresult;
2501 }
2502
2503
2504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2505   void * jresult ;
2506   floatp *arg1 = (floatp *) 0 ;
2507   float *result = 0 ;
2508
2509   arg1 = (floatp *)jarg1;
2510   {
2511     try {
2512       result = (float *)floatp_cast(arg1);
2513     } catch (std::out_of_range& e) {
2514       {
2515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2516       };
2517     } catch (std::exception& e) {
2518       {
2519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2520       };
2521     } catch (...) {
2522       {
2523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2524       };
2525     }
2526   }
2527   jresult = (void *)result;
2528   return jresult;
2529 }
2530
2531
2532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2533   void * jresult ;
2534   float *arg1 = (float *) 0 ;
2535   floatp *result = 0 ;
2536
2537   arg1 = (float *)jarg1;
2538   {
2539     try {
2540       result = (floatp *)floatp_frompointer(arg1);
2541     } catch (std::out_of_range& e) {
2542       {
2543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2544       };
2545     } catch (std::exception& e) {
2546       {
2547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2548       };
2549     } catch (...) {
2550       {
2551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2552       };
2553     }
2554   }
2555   jresult = (void *)result;
2556   return jresult;
2557 }
2558
2559
2560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2561   void * jresult ;
2562   intp *result = 0 ;
2563
2564   {
2565     try {
2566       result = (intp *)new_intp();
2567     } catch (std::out_of_range& e) {
2568       {
2569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2570       };
2571     } catch (std::exception& e) {
2572       {
2573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2574       };
2575     } catch (...) {
2576       {
2577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2578       };
2579     }
2580   }
2581   jresult = (void *)result;
2582   return jresult;
2583 }
2584
2585
2586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2587   intp *arg1 = (intp *) 0 ;
2588
2589   arg1 = (intp *)jarg1;
2590   {
2591     try {
2592       delete_intp(arg1);
2593     } catch (std::out_of_range& e) {
2594       {
2595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2596       };
2597     } catch (std::exception& e) {
2598       {
2599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2600       };
2601     } catch (...) {
2602       {
2603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2604       };
2605     }
2606   }
2607 }
2608
2609
2610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2611   intp *arg1 = (intp *) 0 ;
2612   int arg2 ;
2613
2614   arg1 = (intp *)jarg1;
2615   arg2 = (int)jarg2;
2616   {
2617     try {
2618       intp_assign(arg1,arg2);
2619     } catch (std::out_of_range& e) {
2620       {
2621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2622       };
2623     } catch (std::exception& e) {
2624       {
2625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2626       };
2627     } catch (...) {
2628       {
2629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2630       };
2631     }
2632   }
2633 }
2634
2635
2636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2637   int jresult ;
2638   intp *arg1 = (intp *) 0 ;
2639   int result;
2640
2641   arg1 = (intp *)jarg1;
2642   {
2643     try {
2644       result = (int)intp_value(arg1);
2645     } catch (std::out_of_range& e) {
2646       {
2647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2648       };
2649     } catch (std::exception& e) {
2650       {
2651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2652       };
2653     } catch (...) {
2654       {
2655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2656       };
2657     }
2658   }
2659   jresult = result;
2660   return jresult;
2661 }
2662
2663
2664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2665   void * jresult ;
2666   intp *arg1 = (intp *) 0 ;
2667   int *result = 0 ;
2668
2669   arg1 = (intp *)jarg1;
2670   {
2671     try {
2672       result = (int *)intp_cast(arg1);
2673     } catch (std::out_of_range& e) {
2674       {
2675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2676       };
2677     } catch (std::exception& e) {
2678       {
2679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2680       };
2681     } catch (...) {
2682       {
2683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2684       };
2685     }
2686   }
2687   jresult = (void *)result;
2688   return jresult;
2689 }
2690
2691
2692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2693   void * jresult ;
2694   int *arg1 = (int *) 0 ;
2695   intp *result = 0 ;
2696
2697   arg1 = (int *)jarg1;
2698   {
2699     try {
2700       result = (intp *)intp_frompointer(arg1);
2701     } catch (std::out_of_range& e) {
2702       {
2703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2704       };
2705     } catch (std::exception& e) {
2706       {
2707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2708       };
2709     } catch (...) {
2710       {
2711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2712       };
2713     }
2714   }
2715   jresult = (void *)result;
2716   return jresult;
2717 }
2718
2719
2720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2721   void * jresult ;
2722   doublep *result = 0 ;
2723
2724   {
2725     try {
2726       result = (doublep *)new_doublep();
2727     } catch (std::out_of_range& e) {
2728       {
2729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (std::exception& e) {
2732       {
2733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741   jresult = (void *)result;
2742   return jresult;
2743 }
2744
2745
2746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2747   doublep *arg1 = (doublep *) 0 ;
2748
2749   arg1 = (doublep *)jarg1;
2750   {
2751     try {
2752       delete_doublep(arg1);
2753     } catch (std::out_of_range& e) {
2754       {
2755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2756       };
2757     } catch (std::exception& e) {
2758       {
2759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2760       };
2761     } catch (...) {
2762       {
2763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2764       };
2765     }
2766   }
2767 }
2768
2769
2770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2771   doublep *arg1 = (doublep *) 0 ;
2772   double arg2 ;
2773
2774   arg1 = (doublep *)jarg1;
2775   arg2 = (double)jarg2;
2776   {
2777     try {
2778       doublep_assign(arg1,arg2);
2779     } catch (std::out_of_range& e) {
2780       {
2781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2782       };
2783     } catch (std::exception& e) {
2784       {
2785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2786       };
2787     } catch (...) {
2788       {
2789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2790       };
2791     }
2792   }
2793 }
2794
2795
2796 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2797   double jresult ;
2798   doublep *arg1 = (doublep *) 0 ;
2799   double result;
2800
2801   arg1 = (doublep *)jarg1;
2802   {
2803     try {
2804       result = (double)doublep_value(arg1);
2805     } catch (std::out_of_range& e) {
2806       {
2807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2808       };
2809     } catch (std::exception& e) {
2810       {
2811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2812       };
2813     } catch (...) {
2814       {
2815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2816       };
2817     }
2818   }
2819   jresult = result;
2820   return jresult;
2821 }
2822
2823
2824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2825   void * jresult ;
2826   doublep *arg1 = (doublep *) 0 ;
2827   double *result = 0 ;
2828
2829   arg1 = (doublep *)jarg1;
2830   {
2831     try {
2832       result = (double *)doublep_cast(arg1);
2833     } catch (std::out_of_range& e) {
2834       {
2835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2836       };
2837     } catch (std::exception& e) {
2838       {
2839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2840       };
2841     } catch (...) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2844       };
2845     }
2846   }
2847   jresult = (void *)result;
2848   return jresult;
2849 }
2850
2851
2852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2853   void * jresult ;
2854   double *arg1 = (double *) 0 ;
2855   doublep *result = 0 ;
2856
2857   arg1 = (double *)jarg1;
2858   {
2859     try {
2860       result = (doublep *)doublep_frompointer(arg1);
2861     } catch (std::out_of_range& e) {
2862       {
2863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2864       };
2865     } catch (std::exception& e) {
2866       {
2867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2868       };
2869     } catch (...) {
2870       {
2871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2872       };
2873     }
2874   }
2875   jresult = (void *)result;
2876   return jresult;
2877 }
2878
2879
2880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2881   void * jresult ;
2882   uintp *result = 0 ;
2883
2884   {
2885     try {
2886       result = (uintp *)new_uintp();
2887     } catch (std::out_of_range& e) {
2888       {
2889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2890       };
2891     } catch (std::exception& e) {
2892       {
2893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2894       };
2895     } catch (...) {
2896       {
2897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2898       };
2899     }
2900   }
2901   jresult = (void *)result;
2902   return jresult;
2903 }
2904
2905
2906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2907   uintp *arg1 = (uintp *) 0 ;
2908
2909   arg1 = (uintp *)jarg1;
2910   {
2911     try {
2912       delete_uintp(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2920       };
2921     } catch (...) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2924       };
2925     }
2926   }
2927 }
2928
2929
2930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2931   uintp *arg1 = (uintp *) 0 ;
2932   unsigned int arg2 ;
2933
2934   arg1 = (uintp *)jarg1;
2935   arg2 = (unsigned int)jarg2;
2936   {
2937     try {
2938       uintp_assign(arg1,arg2);
2939     } catch (std::out_of_range& e) {
2940       {
2941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2942       };
2943     } catch (std::exception& e) {
2944       {
2945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2946       };
2947     } catch (...) {
2948       {
2949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2950       };
2951     }
2952   }
2953 }
2954
2955
2956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2957   unsigned int jresult ;
2958   uintp *arg1 = (uintp *) 0 ;
2959   unsigned int result;
2960
2961   arg1 = (uintp *)jarg1;
2962   {
2963     try {
2964       result = (unsigned int)uintp_value(arg1);
2965     } catch (std::out_of_range& e) {
2966       {
2967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2968       };
2969     } catch (std::exception& e) {
2970       {
2971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2972       };
2973     } catch (...) {
2974       {
2975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2976       };
2977     }
2978   }
2979   jresult = result;
2980   return jresult;
2981 }
2982
2983
2984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2985   void * jresult ;
2986   uintp *arg1 = (uintp *) 0 ;
2987   unsigned int *result = 0 ;
2988
2989   arg1 = (uintp *)jarg1;
2990   {
2991     try {
2992       result = (unsigned int *)uintp_cast(arg1);
2993     } catch (std::out_of_range& e) {
2994       {
2995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2996       };
2997     } catch (std::exception& e) {
2998       {
2999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3000       };
3001     } catch (...) {
3002       {
3003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3004       };
3005     }
3006   }
3007   jresult = (void *)result;
3008   return jresult;
3009 }
3010
3011
3012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3013   void * jresult ;
3014   unsigned int *arg1 = (unsigned int *) 0 ;
3015   uintp *result = 0 ;
3016
3017   arg1 = (unsigned int *)jarg1;
3018   {
3019     try {
3020       result = (uintp *)uintp_frompointer(arg1);
3021     } catch (std::out_of_range& e) {
3022       {
3023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3024       };
3025     } catch (std::exception& e) {
3026       {
3027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3028       };
3029     } catch (...) {
3030       {
3031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3032       };
3033     }
3034   }
3035   jresult = (void *)result;
3036   return jresult;
3037 }
3038
3039
3040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3041   void * jresult ;
3042   ushortp *result = 0 ;
3043
3044   {
3045     try {
3046       result = (ushortp *)new_ushortp();
3047     } catch (std::out_of_range& e) {
3048       {
3049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3050       };
3051     } catch (std::exception& e) {
3052       {
3053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3054       };
3055     } catch (...) {
3056       {
3057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3058       };
3059     }
3060   }
3061   jresult = (void *)result;
3062   return jresult;
3063 }
3064
3065
3066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3067   ushortp *arg1 = (ushortp *) 0 ;
3068
3069   arg1 = (ushortp *)jarg1;
3070   {
3071     try {
3072       delete_ushortp(arg1);
3073     } catch (std::out_of_range& e) {
3074       {
3075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3076       };
3077     } catch (std::exception& e) {
3078       {
3079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3080       };
3081     } catch (...) {
3082       {
3083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3084       };
3085     }
3086   }
3087 }
3088
3089
3090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3091   ushortp *arg1 = (ushortp *) 0 ;
3092   unsigned short arg2 ;
3093
3094   arg1 = (ushortp *)jarg1;
3095   arg2 = (unsigned short)jarg2;
3096   {
3097     try {
3098       ushortp_assign(arg1,arg2);
3099     } catch (std::out_of_range& e) {
3100       {
3101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3102       };
3103     } catch (std::exception& e) {
3104       {
3105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3106       };
3107     } catch (...) {
3108       {
3109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3110       };
3111     }
3112   }
3113 }
3114
3115
3116 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3117   unsigned short jresult ;
3118   ushortp *arg1 = (ushortp *) 0 ;
3119   unsigned short result;
3120
3121   arg1 = (ushortp *)jarg1;
3122   {
3123     try {
3124       result = (unsigned short)ushortp_value(arg1);
3125     } catch (std::out_of_range& e) {
3126       {
3127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3128       };
3129     } catch (std::exception& e) {
3130       {
3131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3132       };
3133     } catch (...) {
3134       {
3135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3136       };
3137     }
3138   }
3139   jresult = result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3145   void * jresult ;
3146   ushortp *arg1 = (ushortp *) 0 ;
3147   unsigned short *result = 0 ;
3148
3149   arg1 = (ushortp *)jarg1;
3150   {
3151     try {
3152       result = (unsigned short *)ushortp_cast(arg1);
3153     } catch (std::out_of_range& e) {
3154       {
3155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3156       };
3157     } catch (std::exception& e) {
3158       {
3159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3160       };
3161     } catch (...) {
3162       {
3163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3164       };
3165     }
3166   }
3167   jresult = (void *)result;
3168   return jresult;
3169 }
3170
3171
3172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3173   void * jresult ;
3174   unsigned short *arg1 = (unsigned short *) 0 ;
3175   ushortp *result = 0 ;
3176
3177   arg1 = (unsigned short *)jarg1;
3178   {
3179     try {
3180       result = (ushortp *)ushortp_frompointer(arg1);
3181     } catch (std::out_of_range& e) {
3182       {
3183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3184       };
3185     } catch (std::exception& e) {
3186       {
3187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3188       };
3189     } catch (...) {
3190       {
3191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3192       };
3193     }
3194   }
3195   jresult = (void *)result;
3196   return jresult;
3197 }
3198
3199
3200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3201   unsigned int jresult ;
3202   int arg1 ;
3203   unsigned int result;
3204
3205   arg1 = (int)jarg1;
3206   {
3207     try {
3208       result = (unsigned int)int_to_uint(arg1);
3209     } catch (std::out_of_range& e) {
3210       {
3211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3212       };
3213     } catch (std::exception& e) {
3214       {
3215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (...) {
3218       {
3219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3220       };
3221     }
3222   }
3223   jresult = result;
3224   return jresult;
3225 }
3226
3227
3228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3229   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3230
3231   arg1 = (Dali::RefObject *)jarg1;
3232   {
3233     try {
3234       (arg1)->Reference();
3235     } catch (std::out_of_range& e) {
3236       {
3237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3238       };
3239     } catch (std::exception& e) {
3240       {
3241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3242       };
3243     } catch (...) {
3244       {
3245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3246       };
3247     }
3248   }
3249 }
3250
3251
3252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3253   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3254
3255   arg1 = (Dali::RefObject *)jarg1;
3256   {
3257     try {
3258       (arg1)->Unreference();
3259     } catch (std::out_of_range& e) {
3260       {
3261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3262       };
3263     } catch (std::exception& e) {
3264       {
3265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3266       };
3267     } catch (...) {
3268       {
3269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3270       };
3271     }
3272   }
3273 }
3274
3275
3276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3277   int jresult ;
3278   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3279   int result;
3280
3281   arg1 = (Dali::RefObject *)jarg1;
3282   {
3283     try {
3284       result = (int)(arg1)->ReferenceCount();
3285     } catch (std::out_of_range& e) {
3286       {
3287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3288       };
3289     } catch (std::exception& e) {
3290       {
3291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3292       };
3293     } catch (...) {
3294       {
3295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3296       };
3297     }
3298   }
3299   jresult = result;
3300   return jresult;
3301 }
3302
3303
3304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3305   void * jresult ;
3306   Dali::Any *result = 0 ;
3307
3308   {
3309     try {
3310       result = (Dali::Any *)new Dali::Any();
3311     } catch (std::out_of_range& e) {
3312       {
3313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3314       };
3315     } catch (std::exception& e) {
3316       {
3317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3318       };
3319     } catch (...) {
3320       {
3321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3322       };
3323     }
3324   }
3325   jresult = (void *)result;
3326   return jresult;
3327 }
3328
3329
3330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3331   Dali::Any *arg1 = (Dali::Any *) 0 ;
3332
3333   arg1 = (Dali::Any *)jarg1;
3334   {
3335     try {
3336       delete arg1;
3337     } catch (std::out_of_range& e) {
3338       {
3339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3340       };
3341     } catch (std::exception& e) {
3342       {
3343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3344       };
3345     } catch (...) {
3346       {
3347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3348       };
3349     }
3350   }
3351 }
3352
3353
3354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3355   char *arg1 = (char *) 0 ;
3356
3357   arg1 = (char *)jarg1;
3358   {
3359     try {
3360       Dali::Any::AssertAlways((char const *)arg1);
3361     } catch (std::out_of_range& e) {
3362       {
3363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3364       };
3365     } catch (std::exception& e) {
3366       {
3367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3368       };
3369     } catch (...) {
3370       {
3371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3372       };
3373     }
3374   }
3375 }
3376
3377
3378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3379   void * jresult ;
3380   Dali::Any *arg1 = 0 ;
3381   Dali::Any *result = 0 ;
3382
3383   arg1 = (Dali::Any *)jarg1;
3384   if (!arg1) {
3385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3386     return 0;
3387   }
3388   {
3389     try {
3390       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3391     } catch (std::out_of_range& e) {
3392       {
3393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3394       };
3395     } catch (std::exception& e) {
3396       {
3397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3398       };
3399     } catch (...) {
3400       {
3401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3402       };
3403     }
3404   }
3405   jresult = (void *)result;
3406   return jresult;
3407 }
3408
3409
3410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3411   void * jresult ;
3412   Dali::Any *arg1 = (Dali::Any *) 0 ;
3413   Dali::Any *arg2 = 0 ;
3414   Dali::Any *result = 0 ;
3415
3416   arg1 = (Dali::Any *)jarg1;
3417   arg2 = (Dali::Any *)jarg2;
3418   if (!arg2) {
3419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3420     return 0;
3421   }
3422   {
3423     try {
3424       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3425     } catch (std::out_of_range& e) {
3426       {
3427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3428       };
3429     } catch (std::exception& e) {
3430       {
3431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3432       };
3433     } catch (...) {
3434       {
3435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3436       };
3437     }
3438   }
3439   jresult = (void *)result;
3440   return jresult;
3441 }
3442
3443
3444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3445   void * jresult ;
3446   Dali::Any *arg1 = (Dali::Any *) 0 ;
3447   std::type_info *result = 0 ;
3448
3449   arg1 = (Dali::Any *)jarg1;
3450   {
3451     try {
3452       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3453     } catch (std::out_of_range& e) {
3454       {
3455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3456       };
3457     } catch (std::exception& e) {
3458       {
3459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3460       };
3461     } catch (...) {
3462       {
3463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3464       };
3465     }
3466   }
3467   jresult = (void *)result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3473   unsigned int jresult ;
3474   Dali::Any *arg1 = (Dali::Any *) 0 ;
3475   bool result;
3476
3477   arg1 = (Dali::Any *)jarg1;
3478   {
3479     try {
3480       result = (bool)((Dali::Any const *)arg1)->Empty();
3481     } catch (std::out_of_range& e) {
3482       {
3483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (std::exception& e) {
3486       {
3487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (...) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3492       };
3493     }
3494   }
3495   jresult = result;
3496   return jresult;
3497 }
3498
3499
3500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3501   void * jresult ;
3502   std::type_info *arg1 = 0 ;
3503   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3504   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3505   Dali::Any::AnyContainerBase *result = 0 ;
3506
3507   arg1 = (std::type_info *)jarg1;
3508   if (!arg1) {
3509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3510     return 0;
3511   }
3512   arg2 = (Dali::Any::CloneFunc)jarg2;
3513   arg3 = (Dali::Any::DeleteFunc)jarg3;
3514   {
3515     try {
3516       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3517     } catch (std::out_of_range& e) {
3518       {
3519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (std::exception& e) {
3522       {
3523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3524       };
3525     } catch (...) {
3526       {
3527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3528       };
3529     }
3530   }
3531   jresult = (void *)result;
3532   return jresult;
3533 }
3534
3535
3536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3537   void * jresult ;
3538   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3539   std::type_info *result = 0 ;
3540
3541   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3542   {
3543     try {
3544       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3545     } catch (std::out_of_range& e) {
3546       {
3547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3548       };
3549     } catch (std::exception& e) {
3550       {
3551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (...) {
3554       {
3555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3556       };
3557     }
3558   }
3559   jresult = (void *)result;
3560   return jresult;
3561 }
3562
3563
3564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3565   void * jresult ;
3566   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3567   ::std::type_info *result = 0 ;
3568
3569   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3570   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3571   jresult = (void *)result;
3572   return jresult;
3573 }
3574
3575
3576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3577   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3578   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3579
3580   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3581   arg2 = (Dali::Any::CloneFunc)jarg2;
3582   if (arg1) (arg1)->mCloneFunc = arg2;
3583 }
3584
3585
3586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3587   void * jresult ;
3588   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3589   Dali::Any::CloneFunc result;
3590
3591   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3592   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3593   jresult = (void *)result;
3594   return jresult;
3595 }
3596
3597
3598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3599   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3600   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3601
3602   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3603   arg2 = (Dali::Any::DeleteFunc)jarg2;
3604   if (arg1) (arg1)->mDeleteFunc = arg2;
3605 }
3606
3607
3608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3609   void * jresult ;
3610   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3611   Dali::Any::DeleteFunc result;
3612
3613   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3614   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3615   jresult = (void *)result;
3616   return jresult;
3617 }
3618
3619
3620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3621   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3622
3623   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3624   {
3625     try {
3626       delete arg1;
3627     } catch (std::out_of_range& e) {
3628       {
3629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3630       };
3631     } catch (std::exception& e) {
3632       {
3633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3634       };
3635     } catch (...) {
3636       {
3637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3638       };
3639     }
3640   }
3641 }
3642
3643
3644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3645   Dali::Any *arg1 = (Dali::Any *) 0 ;
3646   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3647
3648   arg1 = (Dali::Any *)jarg1;
3649   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3650   if (arg1) (arg1)->mContainer = arg2;
3651 }
3652
3653
3654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3655   void * jresult ;
3656   Dali::Any *arg1 = (Dali::Any *) 0 ;
3657   Dali::Any::AnyContainerBase *result = 0 ;
3658
3659   arg1 = (Dali::Any *)jarg1;
3660   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3661   jresult = (void *)result;
3662   return jresult;
3663 }
3664
3665
3666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3667   char *arg1 = (char *) 0 ;
3668   char *arg2 = (char *) 0 ;
3669
3670   arg1 = (char *)jarg1;
3671   arg2 = (char *)jarg2;
3672   {
3673     try {
3674       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3675     } catch (std::out_of_range& e) {
3676       {
3677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3678       };
3679     } catch (std::exception& e) {
3680       {
3681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3682       };
3683     } catch (...) {
3684       {
3685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3686       };
3687     }
3688   }
3689 }
3690
3691
3692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3693   void * jresult ;
3694   char *arg1 = (char *) 0 ;
3695   char *arg2 = (char *) 0 ;
3696   Dali::DaliException *result = 0 ;
3697
3698   arg1 = (char *)jarg1;
3699   arg2 = (char *)jarg2;
3700   {
3701     try {
3702       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3703     } catch (std::out_of_range& e) {
3704       {
3705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3706       };
3707     } catch (std::exception& e) {
3708       {
3709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3710       };
3711     } catch (...) {
3712       {
3713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3714       };
3715     }
3716   }
3717   jresult = (void *)result;
3718   return jresult;
3719 }
3720
3721
3722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3723   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3724   char *arg2 = (char *) 0 ;
3725
3726   arg1 = (Dali::DaliException *)jarg1;
3727   arg2 = (char *)jarg2;
3728   {
3729     if (arg2) {
3730       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3731       strcpy((char *)arg1->location, (const char *)arg2);
3732     } else {
3733       arg1->location = 0;
3734     }
3735   }
3736 }
3737
3738
3739 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3740   char * jresult ;
3741   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3742   char *result = 0 ;
3743
3744   arg1 = (Dali::DaliException *)jarg1;
3745   result = (char *) ((arg1)->location);
3746   jresult = SWIG_csharp_string_callback((const char *)result);
3747   return jresult;
3748 }
3749
3750
3751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3752   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3753   char *arg2 = (char *) 0 ;
3754
3755   arg1 = (Dali::DaliException *)jarg1;
3756   arg2 = (char *)jarg2;
3757   {
3758     if (arg2) {
3759       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3760       strcpy((char *)arg1->condition, (const char *)arg2);
3761     } else {
3762       arg1->condition = 0;
3763     }
3764   }
3765 }
3766
3767
3768 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3769   char * jresult ;
3770   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3771   char *result = 0 ;
3772
3773   arg1 = (Dali::DaliException *)jarg1;
3774   result = (char *) ((arg1)->condition);
3775   jresult = SWIG_csharp_string_callback((const char *)result);
3776   return jresult;
3777 }
3778
3779
3780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3781   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3782
3783   arg1 = (Dali::DaliException *)jarg1;
3784   {
3785     try {
3786       delete arg1;
3787     } catch (std::out_of_range& e) {
3788       {
3789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3790       };
3791     } catch (std::exception& e) {
3792       {
3793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3794       };
3795     } catch (...) {
3796       {
3797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3798       };
3799     }
3800   }
3801 }
3802
3803
3804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3805   void * jresult ;
3806   Dali::Vector2 *result = 0 ;
3807
3808   {
3809     try {
3810       result = (Dali::Vector2 *)new Dali::Vector2();
3811     } catch (std::out_of_range& e) {
3812       {
3813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3814       };
3815     } catch (std::exception& e) {
3816       {
3817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3818       };
3819     } catch (...) {
3820       {
3821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3822       };
3823     }
3824   }
3825   jresult = (void *)result;
3826   return jresult;
3827 }
3828
3829
3830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3831   void * jresult ;
3832   float arg1 ;
3833   float arg2 ;
3834   Dali::Vector2 *result = 0 ;
3835
3836   arg1 = (float)jarg1;
3837   arg2 = (float)jarg2;
3838   {
3839     try {
3840       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3841     } catch (std::out_of_range& e) {
3842       {
3843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3844       };
3845     } catch (std::exception& e) {
3846       {
3847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3848       };
3849     } catch (...) {
3850       {
3851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3852       };
3853     }
3854   }
3855   jresult = (void *)result;
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3861   void * jresult ;
3862   float *arg1 = (float *) 0 ;
3863   Dali::Vector2 *result = 0 ;
3864
3865   arg1 = jarg1;
3866   {
3867     try {
3868       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3869     } catch (std::out_of_range& e) {
3870       {
3871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (std::exception& e) {
3874       {
3875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3876       };
3877     } catch (...) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3880       };
3881     }
3882   }
3883   jresult = (void *)result;
3884
3885
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3891   void * jresult ;
3892   Dali::Vector3 *arg1 = 0 ;
3893   Dali::Vector2 *result = 0 ;
3894
3895   arg1 = (Dali::Vector3 *)jarg1;
3896   if (!arg1) {
3897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3898     return 0;
3899   }
3900   {
3901     try {
3902       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3903     } catch (std::out_of_range& e) {
3904       {
3905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3906       };
3907     } catch (std::exception& e) {
3908       {
3909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3910       };
3911     } catch (...) {
3912       {
3913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3914       };
3915     }
3916   }
3917   jresult = (void *)result;
3918   return jresult;
3919 }
3920
3921
3922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3923   void * jresult ;
3924   Dali::Vector4 *arg1 = 0 ;
3925   Dali::Vector2 *result = 0 ;
3926
3927   arg1 = (Dali::Vector4 *)jarg1;
3928   if (!arg1) {
3929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3930     return 0;
3931   }
3932   {
3933     try {
3934       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3935     } catch (std::out_of_range& e) {
3936       {
3937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3938       };
3939     } catch (std::exception& e) {
3940       {
3941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3942       };
3943     } catch (...) {
3944       {
3945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3946       };
3947     }
3948   }
3949   jresult = (void *)result;
3950   return jresult;
3951 }
3952
3953
3954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3955   void * jresult ;
3956   Dali::Vector2 *result = 0 ;
3957
3958   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3959   jresult = (void *)result;
3960   return jresult;
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3965   void * jresult ;
3966   Dali::Vector2 *result = 0 ;
3967
3968   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3969   jresult = (void *)result;
3970   return jresult;
3971 }
3972
3973
3974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3975   void * jresult ;
3976   Dali::Vector2 *result = 0 ;
3977
3978   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3979   jresult = (void *)result;
3980   return jresult;
3981 }
3982
3983
3984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3985   void * jresult ;
3986   Dali::Vector2 *result = 0 ;
3987
3988   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3989   jresult = (void *)result;
3990   return jresult;
3991 }
3992
3993
3994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3995   void * jresult ;
3996   Dali::Vector2 *result = 0 ;
3997
3998   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3999   jresult = (void *)result;
4000   return jresult;
4001 }
4002
4003
4004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4005   void * jresult ;
4006   Dali::Vector2 *result = 0 ;
4007
4008   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4009   jresult = (void *)result;
4010   return jresult;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4015   void * jresult ;
4016   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4017   float *arg2 = (float *) 0 ;
4018   Dali::Vector2 *result = 0 ;
4019
4020   arg1 = (Dali::Vector2 *)jarg1;
4021   arg2 = jarg2;
4022   {
4023     try {
4024       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4025     } catch (std::out_of_range& e) {
4026       {
4027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4028       };
4029     } catch (std::exception& e) {
4030       {
4031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4032       };
4033     } catch (...) {
4034       {
4035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4036       };
4037     }
4038   }
4039   jresult = (void *)result;
4040
4041
4042   return jresult;
4043 }
4044
4045
4046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4047   void * jresult ;
4048   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4049   Dali::Vector3 *arg2 = 0 ;
4050   Dali::Vector2 *result = 0 ;
4051
4052   arg1 = (Dali::Vector2 *)jarg1;
4053   arg2 = (Dali::Vector3 *)jarg2;
4054   if (!arg2) {
4055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4056     return 0;
4057   }
4058   {
4059     try {
4060       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4061     } catch (std::out_of_range& e) {
4062       {
4063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4064       };
4065     } catch (std::exception& e) {
4066       {
4067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4068       };
4069     } catch (...) {
4070       {
4071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4072       };
4073     }
4074   }
4075   jresult = (void *)result;
4076   return jresult;
4077 }
4078
4079
4080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4081   void * jresult ;
4082   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4083   Dali::Vector4 *arg2 = 0 ;
4084   Dali::Vector2 *result = 0 ;
4085
4086   arg1 = (Dali::Vector2 *)jarg1;
4087   arg2 = (Dali::Vector4 *)jarg2;
4088   if (!arg2) {
4089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4090     return 0;
4091   }
4092   {
4093     try {
4094       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4095     } catch (std::out_of_range& e) {
4096       {
4097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4098       };
4099     } catch (std::exception& e) {
4100       {
4101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4102       };
4103     } catch (...) {
4104       {
4105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4106       };
4107     }
4108   }
4109   jresult = (void *)result;
4110   return jresult;
4111 }
4112
4113
4114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4115   void * jresult ;
4116   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4117   Dali::Vector2 *arg2 = 0 ;
4118   Dali::Vector2 result;
4119
4120   arg1 = (Dali::Vector2 *)jarg1;
4121   arg2 = (Dali::Vector2 *)jarg2;
4122   if (!arg2) {
4123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4124     return 0;
4125   }
4126   {
4127     try {
4128       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4129     } catch (std::out_of_range& e) {
4130       {
4131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4132       };
4133     } catch (std::exception& e) {
4134       {
4135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4136       };
4137     } catch (...) {
4138       {
4139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4140       };
4141     }
4142   }
4143   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4144   return jresult;
4145 }
4146
4147
4148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4149   void * jresult ;
4150   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4151   Dali::Vector2 *arg2 = 0 ;
4152   Dali::Vector2 *result = 0 ;
4153
4154   arg1 = (Dali::Vector2 *)jarg1;
4155   arg2 = (Dali::Vector2 *)jarg2;
4156   if (!arg2) {
4157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4158     return 0;
4159   }
4160   {
4161     try {
4162       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4163     } catch (std::out_of_range& e) {
4164       {
4165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4166       };
4167     } catch (std::exception& e) {
4168       {
4169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4170       };
4171     } catch (...) {
4172       {
4173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4174       };
4175     }
4176   }
4177   jresult = (void *)result;
4178   return jresult;
4179 }
4180
4181
4182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4183   void * jresult ;
4184   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4185   Dali::Vector2 *arg2 = 0 ;
4186   Dali::Vector2 result;
4187
4188   arg1 = (Dali::Vector2 *)jarg1;
4189   arg2 = (Dali::Vector2 *)jarg2;
4190   if (!arg2) {
4191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4192     return 0;
4193   }
4194   {
4195     try {
4196       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4197     } catch (std::out_of_range& e) {
4198       {
4199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4200       };
4201     } catch (std::exception& e) {
4202       {
4203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4204       };
4205     } catch (...) {
4206       {
4207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4208       };
4209     }
4210   }
4211   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4212   return jresult;
4213 }
4214
4215
4216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4217   void * jresult ;
4218   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4219   Dali::Vector2 *arg2 = 0 ;
4220   Dali::Vector2 *result = 0 ;
4221
4222   arg1 = (Dali::Vector2 *)jarg1;
4223   arg2 = (Dali::Vector2 *)jarg2;
4224   if (!arg2) {
4225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4226     return 0;
4227   }
4228   {
4229     try {
4230       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (...) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4242       };
4243     }
4244   }
4245   jresult = (void *)result;
4246   return jresult;
4247 }
4248
4249
4250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4251   void * jresult ;
4252   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4253   Dali::Vector2 *arg2 = 0 ;
4254   Dali::Vector2 result;
4255
4256   arg1 = (Dali::Vector2 *)jarg1;
4257   arg2 = (Dali::Vector2 *)jarg2;
4258   if (!arg2) {
4259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4260     return 0;
4261   }
4262   {
4263     try {
4264       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4265     } catch (std::out_of_range& e) {
4266       {
4267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4268       };
4269     } catch (std::exception& e) {
4270       {
4271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4272       };
4273     } catch (...) {
4274       {
4275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4276       };
4277     }
4278   }
4279   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4280   return jresult;
4281 }
4282
4283
4284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4285   void * jresult ;
4286   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4287   float arg2 ;
4288   Dali::Vector2 result;
4289
4290   arg1 = (Dali::Vector2 *)jarg1;
4291   arg2 = (float)jarg2;
4292   {
4293     try {
4294       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4295     } catch (std::out_of_range& e) {
4296       {
4297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (std::exception& e) {
4300       {
4301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (...) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4306       };
4307     }
4308   }
4309   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4310   return jresult;
4311 }
4312
4313
4314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4315   void * jresult ;
4316   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4317   Dali::Vector2 *arg2 = 0 ;
4318   Dali::Vector2 *result = 0 ;
4319
4320   arg1 = (Dali::Vector2 *)jarg1;
4321   arg2 = (Dali::Vector2 *)jarg2;
4322   if (!arg2) {
4323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4324     return 0;
4325   }
4326   {
4327     try {
4328       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4329     } catch (std::out_of_range& e) {
4330       {
4331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (std::exception& e) {
4334       {
4335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4336       };
4337     } catch (...) {
4338       {
4339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4340       };
4341     }
4342   }
4343   jresult = (void *)result;
4344   return jresult;
4345 }
4346
4347
4348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4349   void * jresult ;
4350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4351   float arg2 ;
4352   Dali::Vector2 *result = 0 ;
4353
4354   arg1 = (Dali::Vector2 *)jarg1;
4355   arg2 = (float)jarg2;
4356   {
4357     try {
4358       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4359     } catch (std::out_of_range& e) {
4360       {
4361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4362       };
4363     } catch (std::exception& e) {
4364       {
4365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4366       };
4367     } catch (...) {
4368       {
4369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4370       };
4371     }
4372   }
4373   jresult = (void *)result;
4374   return jresult;
4375 }
4376
4377
4378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4379   void * jresult ;
4380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4381   Dali::Vector2 *arg2 = 0 ;
4382   Dali::Vector2 result;
4383
4384   arg1 = (Dali::Vector2 *)jarg1;
4385   arg2 = (Dali::Vector2 *)jarg2;
4386   if (!arg2) {
4387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4388     return 0;
4389   }
4390   {
4391     try {
4392       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4393     } catch (std::out_of_range& e) {
4394       {
4395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4396       };
4397     } catch (std::exception& e) {
4398       {
4399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4400       };
4401     } catch (...) {
4402       {
4403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4404       };
4405     }
4406   }
4407   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4408   return jresult;
4409 }
4410
4411
4412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4413   void * jresult ;
4414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4415   float arg2 ;
4416   Dali::Vector2 result;
4417
4418   arg1 = (Dali::Vector2 *)jarg1;
4419   arg2 = (float)jarg2;
4420   {
4421     try {
4422       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4423     } catch (std::out_of_range& e) {
4424       {
4425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4426       };
4427     } catch (std::exception& e) {
4428       {
4429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4430       };
4431     } catch (...) {
4432       {
4433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4434       };
4435     }
4436   }
4437   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4438   return jresult;
4439 }
4440
4441
4442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4443   void * jresult ;
4444   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4445   Dali::Vector2 *arg2 = 0 ;
4446   Dali::Vector2 *result = 0 ;
4447
4448   arg1 = (Dali::Vector2 *)jarg1;
4449   arg2 = (Dali::Vector2 *)jarg2;
4450   if (!arg2) {
4451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4452     return 0;
4453   }
4454   {
4455     try {
4456       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4457     } catch (std::out_of_range& e) {
4458       {
4459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4460       };
4461     } catch (std::exception& e) {
4462       {
4463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4464       };
4465     } catch (...) {
4466       {
4467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4468       };
4469     }
4470   }
4471   jresult = (void *)result;
4472   return jresult;
4473 }
4474
4475
4476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4477   void * jresult ;
4478   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4479   float arg2 ;
4480   Dali::Vector2 *result = 0 ;
4481
4482   arg1 = (Dali::Vector2 *)jarg1;
4483   arg2 = (float)jarg2;
4484   {
4485     try {
4486       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4487     } catch (std::out_of_range& e) {
4488       {
4489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4490       };
4491     } catch (std::exception& e) {
4492       {
4493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4494       };
4495     } catch (...) {
4496       {
4497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4498       };
4499     }
4500   }
4501   jresult = (void *)result;
4502   return jresult;
4503 }
4504
4505
4506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4507   void * jresult ;
4508   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4509   Dali::Vector2 result;
4510
4511   arg1 = (Dali::Vector2 *)jarg1;
4512   {
4513     try {
4514       result = ((Dali::Vector2 const *)arg1)->operator -();
4515     } catch (std::out_of_range& e) {
4516       {
4517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (std::exception& e) {
4520       {
4521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4530   return jresult;
4531 }
4532
4533
4534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4535   unsigned int jresult ;
4536   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4537   Dali::Vector2 *arg2 = 0 ;
4538   bool result;
4539
4540   arg1 = (Dali::Vector2 *)jarg1;
4541   arg2 = (Dali::Vector2 *)jarg2;
4542   if (!arg2) {
4543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4544     return 0;
4545   }
4546   {
4547     try {
4548       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4549     } catch (std::out_of_range& e) {
4550       {
4551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4552       };
4553     } catch (std::exception& e) {
4554       {
4555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4556       };
4557     } catch (...) {
4558       {
4559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4560       };
4561     }
4562   }
4563   jresult = result;
4564   return jresult;
4565 }
4566
4567
4568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4569   unsigned int jresult ;
4570   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4571   Dali::Vector2 *arg2 = 0 ;
4572   bool result;
4573
4574   arg1 = (Dali::Vector2 *)jarg1;
4575   arg2 = (Dali::Vector2 *)jarg2;
4576   if (!arg2) {
4577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4578     return 0;
4579   }
4580   {
4581     try {
4582       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4583     } catch (std::out_of_range& e) {
4584       {
4585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4586       };
4587     } catch (std::exception& e) {
4588       {
4589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (...) {
4592       {
4593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4594       };
4595     }
4596   }
4597   jresult = result;
4598   return jresult;
4599 }
4600
4601
4602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4603   float jresult ;
4604   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4605   unsigned int arg2 ;
4606   float *result = 0 ;
4607
4608   arg1 = (Dali::Vector2 *)jarg1;
4609   arg2 = (unsigned int)jarg2;
4610   {
4611     try {
4612       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4613     } catch (std::out_of_range& e) {
4614       {
4615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4616       };
4617     } catch (std::exception& e) {
4618       {
4619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4620       };
4621     } catch (...) {
4622       {
4623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4624       };
4625     }
4626   }
4627   jresult = *result;
4628   return jresult;
4629 }
4630
4631
4632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4633   float jresult ;
4634   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4635   float result;
4636
4637   arg1 = (Dali::Vector2 *)jarg1;
4638   {
4639     try {
4640       result = (float)((Dali::Vector2 const *)arg1)->Length();
4641     } catch (std::out_of_range& e) {
4642       {
4643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4644       };
4645     } catch (std::exception& e) {
4646       {
4647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4648       };
4649     } catch (...) {
4650       {
4651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4652       };
4653     }
4654   }
4655   jresult = result;
4656   return jresult;
4657 }
4658
4659
4660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4661   float jresult ;
4662   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4663   float result;
4664
4665   arg1 = (Dali::Vector2 *)jarg1;
4666   {
4667     try {
4668       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4669     } catch (std::out_of_range& e) {
4670       {
4671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4672       };
4673     } catch (std::exception& e) {
4674       {
4675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4676       };
4677     } catch (...) {
4678       {
4679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4680       };
4681     }
4682   }
4683   jresult = result;
4684   return jresult;
4685 }
4686
4687
4688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4689   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4690
4691   arg1 = (Dali::Vector2 *)jarg1;
4692   {
4693     try {
4694       (arg1)->Normalize();
4695     } catch (std::out_of_range& e) {
4696       {
4697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4698       };
4699     } catch (std::exception& e) {
4700       {
4701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4702       };
4703     } catch (...) {
4704       {
4705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4706       };
4707     }
4708   }
4709 }
4710
4711
4712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4713   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4714   Dali::Vector2 *arg2 = 0 ;
4715   Dali::Vector2 *arg3 = 0 ;
4716
4717   arg1 = (Dali::Vector2 *)jarg1;
4718   arg2 = (Dali::Vector2 *)jarg2;
4719   if (!arg2) {
4720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4721     return ;
4722   }
4723   arg3 = (Dali::Vector2 *)jarg3;
4724   if (!arg3) {
4725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4726     return ;
4727   }
4728   {
4729     try {
4730       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4731     } catch (std::out_of_range& e) {
4732       {
4733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4734       };
4735     } catch (std::exception& e) {
4736       {
4737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4738       };
4739     } catch (...) {
4740       {
4741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4742       };
4743     }
4744   }
4745 }
4746
4747
4748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4749   void * jresult ;
4750   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4751   float *result = 0 ;
4752
4753   arg1 = (Dali::Vector2 *)jarg1;
4754   {
4755     try {
4756       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4757     } catch (std::out_of_range& e) {
4758       {
4759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4760       };
4761     } catch (std::exception& e) {
4762       {
4763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4764       };
4765     } catch (...) {
4766       {
4767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4768       };
4769     }
4770   }
4771   jresult = (void *)result;
4772   return jresult;
4773 }
4774
4775
4776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4777   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4778   float arg2 ;
4779
4780   arg1 = (Dali::Vector2 *)jarg1;
4781   arg2 = (float)jarg2;
4782   if (arg1) (arg1)->x = arg2;
4783 }
4784
4785
4786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4787   float jresult ;
4788   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4789   float result;
4790
4791   arg1 = (Dali::Vector2 *)jarg1;
4792   result = (float) ((arg1)->x);
4793   jresult = result;
4794   return jresult;
4795 }
4796
4797
4798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4799   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4800   float arg2 ;
4801
4802   arg1 = (Dali::Vector2 *)jarg1;
4803   arg2 = (float)jarg2;
4804   if (arg1) (arg1)->width = arg2;
4805 }
4806
4807
4808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4809   float jresult ;
4810   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4811   float result;
4812
4813   arg1 = (Dali::Vector2 *)jarg1;
4814   result = (float) ((arg1)->width);
4815   jresult = result;
4816   return jresult;
4817 }
4818
4819
4820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4821   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4822   float arg2 ;
4823
4824   arg1 = (Dali::Vector2 *)jarg1;
4825   arg2 = (float)jarg2;
4826   if (arg1) (arg1)->y = arg2;
4827 }
4828
4829
4830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4831   float jresult ;
4832   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4833   float result;
4834
4835   arg1 = (Dali::Vector2 *)jarg1;
4836   result = (float) ((arg1)->y);
4837   jresult = result;
4838   return jresult;
4839 }
4840
4841
4842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4843   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4844   float arg2 ;
4845
4846   arg1 = (Dali::Vector2 *)jarg1;
4847   arg2 = (float)jarg2;
4848   if (arg1) (arg1)->height = arg2;
4849 }
4850
4851
4852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4853   float jresult ;
4854   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4855   float result;
4856
4857   arg1 = (Dali::Vector2 *)jarg1;
4858   result = (float) ((arg1)->height);
4859   jresult = result;
4860   return jresult;
4861 }
4862
4863
4864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4865   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4866
4867   arg1 = (Dali::Vector2 *)jarg1;
4868   {
4869     try {
4870       delete arg1;
4871     } catch (std::out_of_range& e) {
4872       {
4873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4874       };
4875     } catch (std::exception& e) {
4876       {
4877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4878       };
4879     } catch (...) {
4880       {
4881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4882       };
4883     }
4884   }
4885 }
4886
4887
4888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4889   void * jresult ;
4890   Dali::Vector2 *arg1 = 0 ;
4891   Dali::Vector2 *arg2 = 0 ;
4892   Dali::Vector2 result;
4893
4894   arg1 = (Dali::Vector2 *)jarg1;
4895   if (!arg1) {
4896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4897     return 0;
4898   }
4899   arg2 = (Dali::Vector2 *)jarg2;
4900   if (!arg2) {
4901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4902     return 0;
4903   }
4904   {
4905     try {
4906       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4907     } catch (std::out_of_range& e) {
4908       {
4909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4910       };
4911     } catch (std::exception& e) {
4912       {
4913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4914       };
4915     } catch (...) {
4916       {
4917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4918       };
4919     }
4920   }
4921   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4922   return jresult;
4923 }
4924
4925
4926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4927   void * jresult ;
4928   Dali::Vector2 *arg1 = 0 ;
4929   Dali::Vector2 *arg2 = 0 ;
4930   Dali::Vector2 result;
4931
4932   arg1 = (Dali::Vector2 *)jarg1;
4933   if (!arg1) {
4934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4935     return 0;
4936   }
4937   arg2 = (Dali::Vector2 *)jarg2;
4938   if (!arg2) {
4939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4940     return 0;
4941   }
4942   {
4943     try {
4944       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4945     } catch (std::out_of_range& e) {
4946       {
4947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4948       };
4949     } catch (std::exception& e) {
4950       {
4951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4952       };
4953     } catch (...) {
4954       {
4955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4956       };
4957     }
4958   }
4959   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4960   return jresult;
4961 }
4962
4963
4964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4965   void * jresult ;
4966   Dali::Vector2 *arg1 = 0 ;
4967   float *arg2 = 0 ;
4968   float *arg3 = 0 ;
4969   float temp2 ;
4970   float temp3 ;
4971   Dali::Vector2 result;
4972
4973   arg1 = (Dali::Vector2 *)jarg1;
4974   if (!arg1) {
4975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4976     return 0;
4977   }
4978   temp2 = (float)jarg2;
4979   arg2 = &temp2;
4980   temp3 = (float)jarg3;
4981   arg3 = &temp3;
4982   {
4983     try {
4984       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4985     } catch (std::out_of_range& e) {
4986       {
4987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4988       };
4989     } catch (std::exception& e) {
4990       {
4991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4992       };
4993     } catch (...) {
4994       {
4995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4996       };
4997     }
4998   }
4999   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5000   return jresult;
5001 }
5002
5003
5004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5005   void * jresult ;
5006   Dali::Vector3 *result = 0 ;
5007
5008   {
5009     try {
5010       result = (Dali::Vector3 *)new Dali::Vector3();
5011     } catch (std::out_of_range& e) {
5012       {
5013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (std::exception& e) {
5016       {
5017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5018       };
5019     } catch (...) {
5020       {
5021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5022       };
5023     }
5024   }
5025   jresult = (void *)result;
5026   return jresult;
5027 }
5028
5029
5030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5031   void * jresult ;
5032   float arg1 ;
5033   float arg2 ;
5034   float arg3 ;
5035   Dali::Vector3 *result = 0 ;
5036
5037   arg1 = (float)jarg1;
5038   arg2 = (float)jarg2;
5039   arg3 = (float)jarg3;
5040   {
5041     try {
5042       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5043     } catch (std::out_of_range& e) {
5044       {
5045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5046       };
5047     } catch (std::exception& e) {
5048       {
5049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5050       };
5051     } catch (...) {
5052       {
5053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5054       };
5055     }
5056   }
5057   jresult = (void *)result;
5058   return jresult;
5059 }
5060
5061
5062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5063   void * jresult ;
5064   float *arg1 = (float *) 0 ;
5065   Dali::Vector3 *result = 0 ;
5066
5067   arg1 = jarg1;
5068   {
5069     try {
5070       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (...) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5082       };
5083     }
5084   }
5085   jresult = (void *)result;
5086
5087
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5093   void * jresult ;
5094   Dali::Vector2 *arg1 = 0 ;
5095   Dali::Vector3 *result = 0 ;
5096
5097   arg1 = (Dali::Vector2 *)jarg1;
5098   if (!arg1) {
5099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5100     return 0;
5101   }
5102   {
5103     try {
5104       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5105     } catch (std::out_of_range& e) {
5106       {
5107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (std::exception& e) {
5110       {
5111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5112       };
5113     } catch (...) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5116       };
5117     }
5118   }
5119   jresult = (void *)result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5125   void * jresult ;
5126   Dali::Vector4 *arg1 = 0 ;
5127   Dali::Vector3 *result = 0 ;
5128
5129   arg1 = (Dali::Vector4 *)jarg1;
5130   if (!arg1) {
5131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5132     return 0;
5133   }
5134   {
5135     try {
5136       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5137     } catch (std::out_of_range& e) {
5138       {
5139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5140       };
5141     } catch (std::exception& e) {
5142       {
5143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5144       };
5145     } catch (...) {
5146       {
5147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5148       };
5149     }
5150   }
5151   jresult = (void *)result;
5152   return jresult;
5153 }
5154
5155
5156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5157   void * jresult ;
5158   Dali::Vector3 *result = 0 ;
5159
5160   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5161   jresult = (void *)result;
5162   return jresult;
5163 }
5164
5165
5166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5167   void * jresult ;
5168   Dali::Vector3 *result = 0 ;
5169
5170   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5171   jresult = (void *)result;
5172   return jresult;
5173 }
5174
5175
5176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5177   void * jresult ;
5178   Dali::Vector3 *result = 0 ;
5179
5180   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5181   jresult = (void *)result;
5182   return jresult;
5183 }
5184
5185
5186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5187   void * jresult ;
5188   Dali::Vector3 *result = 0 ;
5189
5190   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5191   jresult = (void *)result;
5192   return jresult;
5193 }
5194
5195
5196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5197   void * jresult ;
5198   Dali::Vector3 *result = 0 ;
5199
5200   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5201   jresult = (void *)result;
5202   return jresult;
5203 }
5204
5205
5206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5207   void * jresult ;
5208   Dali::Vector3 *result = 0 ;
5209
5210   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5211   jresult = (void *)result;
5212   return jresult;
5213 }
5214
5215
5216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5217   void * jresult ;
5218   Dali::Vector3 *result = 0 ;
5219
5220   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5221   jresult = (void *)result;
5222   return jresult;
5223 }
5224
5225
5226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5227   void * jresult ;
5228   Dali::Vector3 *result = 0 ;
5229
5230   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5231   jresult = (void *)result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5237   void * jresult ;
5238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5239   float *arg2 = (float *) 0 ;
5240   Dali::Vector3 *result = 0 ;
5241
5242   arg1 = (Dali::Vector3 *)jarg1;
5243   arg2 = jarg2;
5244   {
5245     try {
5246       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5247     } catch (std::out_of_range& e) {
5248       {
5249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5250       };
5251     } catch (std::exception& e) {
5252       {
5253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5254       };
5255     } catch (...) {
5256       {
5257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5258       };
5259     }
5260   }
5261   jresult = (void *)result;
5262
5263
5264   return jresult;
5265 }
5266
5267
5268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5269   void * jresult ;
5270   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5271   Dali::Vector2 *arg2 = 0 ;
5272   Dali::Vector3 *result = 0 ;
5273
5274   arg1 = (Dali::Vector3 *)jarg1;
5275   arg2 = (Dali::Vector2 *)jarg2;
5276   if (!arg2) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5278     return 0;
5279   }
5280   {
5281     try {
5282       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5283     } catch (std::out_of_range& e) {
5284       {
5285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5286       };
5287     } catch (std::exception& e) {
5288       {
5289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5290       };
5291     } catch (...) {
5292       {
5293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5294       };
5295     }
5296   }
5297   jresult = (void *)result;
5298   return jresult;
5299 }
5300
5301
5302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5303   void * jresult ;
5304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5305   Dali::Vector4 *arg2 = 0 ;
5306   Dali::Vector3 *result = 0 ;
5307
5308   arg1 = (Dali::Vector3 *)jarg1;
5309   arg2 = (Dali::Vector4 *)jarg2;
5310   if (!arg2) {
5311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5312     return 0;
5313   }
5314   {
5315     try {
5316       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5317     } catch (std::out_of_range& e) {
5318       {
5319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (std::exception& e) {
5322       {
5323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (...) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5328       };
5329     }
5330   }
5331   jresult = (void *)result;
5332   return jresult;
5333 }
5334
5335
5336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5337   void * jresult ;
5338   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5339   Dali::Vector3 *arg2 = 0 ;
5340   Dali::Vector3 result;
5341
5342   arg1 = (Dali::Vector3 *)jarg1;
5343   arg2 = (Dali::Vector3 *)jarg2;
5344   if (!arg2) {
5345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5346     return 0;
5347   }
5348   {
5349     try {
5350       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5351     } catch (std::out_of_range& e) {
5352       {
5353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5354       };
5355     } catch (std::exception& e) {
5356       {
5357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5358       };
5359     } catch (...) {
5360       {
5361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5362       };
5363     }
5364   }
5365   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5366   return jresult;
5367 }
5368
5369
5370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5371   void * jresult ;
5372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5373   Dali::Vector3 *arg2 = 0 ;
5374   Dali::Vector3 *result = 0 ;
5375
5376   arg1 = (Dali::Vector3 *)jarg1;
5377   arg2 = (Dali::Vector3 *)jarg2;
5378   if (!arg2) {
5379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5380     return 0;
5381   }
5382   {
5383     try {
5384       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5385     } catch (std::out_of_range& e) {
5386       {
5387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5388       };
5389     } catch (std::exception& e) {
5390       {
5391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5392       };
5393     } catch (...) {
5394       {
5395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5396       };
5397     }
5398   }
5399   jresult = (void *)result;
5400   return jresult;
5401 }
5402
5403
5404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5405   void * jresult ;
5406   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5407   Dali::Vector3 *arg2 = 0 ;
5408   Dali::Vector3 result;
5409
5410   arg1 = (Dali::Vector3 *)jarg1;
5411   arg2 = (Dali::Vector3 *)jarg2;
5412   if (!arg2) {
5413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5414     return 0;
5415   }
5416   {
5417     try {
5418       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5419     } catch (std::out_of_range& e) {
5420       {
5421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5422       };
5423     } catch (std::exception& e) {
5424       {
5425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5426       };
5427     } catch (...) {
5428       {
5429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5430       };
5431     }
5432   }
5433   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5434   return jresult;
5435 }
5436
5437
5438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5439   void * jresult ;
5440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5441   Dali::Vector3 *arg2 = 0 ;
5442   Dali::Vector3 *result = 0 ;
5443
5444   arg1 = (Dali::Vector3 *)jarg1;
5445   arg2 = (Dali::Vector3 *)jarg2;
5446   if (!arg2) {
5447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5448     return 0;
5449   }
5450   {
5451     try {
5452       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5453     } catch (std::out_of_range& e) {
5454       {
5455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5456       };
5457     } catch (std::exception& e) {
5458       {
5459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5460       };
5461     } catch (...) {
5462       {
5463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5464       };
5465     }
5466   }
5467   jresult = (void *)result;
5468   return jresult;
5469 }
5470
5471
5472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5473   void * jresult ;
5474   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5475   Dali::Vector3 *arg2 = 0 ;
5476   Dali::Vector3 result;
5477
5478   arg1 = (Dali::Vector3 *)jarg1;
5479   arg2 = (Dali::Vector3 *)jarg2;
5480   if (!arg2) {
5481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5482     return 0;
5483   }
5484   {
5485     try {
5486       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5487     } catch (std::out_of_range& e) {
5488       {
5489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5490       };
5491     } catch (std::exception& e) {
5492       {
5493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5494       };
5495     } catch (...) {
5496       {
5497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5498       };
5499     }
5500   }
5501   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5502   return jresult;
5503 }
5504
5505
5506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5507   void * jresult ;
5508   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5509   float arg2 ;
5510   Dali::Vector3 result;
5511
5512   arg1 = (Dali::Vector3 *)jarg1;
5513   arg2 = (float)jarg2;
5514   {
5515     try {
5516       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (...) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5528       };
5529     }
5530   }
5531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5532   return jresult;
5533 }
5534
5535
5536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5537   void * jresult ;
5538   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5539   Dali::Vector3 *arg2 = 0 ;
5540   Dali::Vector3 *result = 0 ;
5541
5542   arg1 = (Dali::Vector3 *)jarg1;
5543   arg2 = (Dali::Vector3 *)jarg2;
5544   if (!arg2) {
5545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5546     return 0;
5547   }
5548   {
5549     try {
5550       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5551     } catch (std::out_of_range& e) {
5552       {
5553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5554       };
5555     } catch (std::exception& e) {
5556       {
5557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5558       };
5559     } catch (...) {
5560       {
5561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5562       };
5563     }
5564   }
5565   jresult = (void *)result;
5566   return jresult;
5567 }
5568
5569
5570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5571   void * jresult ;
5572   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5573   float arg2 ;
5574   Dali::Vector3 *result = 0 ;
5575
5576   arg1 = (Dali::Vector3 *)jarg1;
5577   arg2 = (float)jarg2;
5578   {
5579     try {
5580       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5581     } catch (std::out_of_range& e) {
5582       {
5583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5584       };
5585     } catch (std::exception& e) {
5586       {
5587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5588       };
5589     } catch (...) {
5590       {
5591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5592       };
5593     }
5594   }
5595   jresult = (void *)result;
5596   return jresult;
5597 }
5598
5599
5600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5601   void * jresult ;
5602   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5603   Dali::Quaternion *arg2 = 0 ;
5604   Dali::Vector3 *result = 0 ;
5605
5606   arg1 = (Dali::Vector3 *)jarg1;
5607   arg2 = (Dali::Quaternion *)jarg2;
5608   if (!arg2) {
5609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5610     return 0;
5611   }
5612   {
5613     try {
5614       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5615     } catch (std::out_of_range& e) {
5616       {
5617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5618       };
5619     } catch (std::exception& e) {
5620       {
5621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5622       };
5623     } catch (...) {
5624       {
5625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5626       };
5627     }
5628   }
5629   jresult = (void *)result;
5630   return jresult;
5631 }
5632
5633
5634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5635   void * jresult ;
5636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5637   Dali::Vector3 *arg2 = 0 ;
5638   Dali::Vector3 result;
5639
5640   arg1 = (Dali::Vector3 *)jarg1;
5641   arg2 = (Dali::Vector3 *)jarg2;
5642   if (!arg2) {
5643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5644     return 0;
5645   }
5646   {
5647     try {
5648       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5649     } catch (std::out_of_range& e) {
5650       {
5651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5652       };
5653     } catch (std::exception& e) {
5654       {
5655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5656       };
5657     } catch (...) {
5658       {
5659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5660       };
5661     }
5662   }
5663   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5664   return jresult;
5665 }
5666
5667
5668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5669   void * jresult ;
5670   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5671   float arg2 ;
5672   Dali::Vector3 result;
5673
5674   arg1 = (Dali::Vector3 *)jarg1;
5675   arg2 = (float)jarg2;
5676   {
5677     try {
5678       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5679     } catch (std::out_of_range& e) {
5680       {
5681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5682       };
5683     } catch (std::exception& e) {
5684       {
5685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5686       };
5687     } catch (...) {
5688       {
5689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5690       };
5691     }
5692   }
5693   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5694   return jresult;
5695 }
5696
5697
5698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5699   void * jresult ;
5700   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5701   Dali::Vector3 *arg2 = 0 ;
5702   Dali::Vector3 *result = 0 ;
5703
5704   arg1 = (Dali::Vector3 *)jarg1;
5705   arg2 = (Dali::Vector3 *)jarg2;
5706   if (!arg2) {
5707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5708     return 0;
5709   }
5710   {
5711     try {
5712       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5713     } catch (std::out_of_range& e) {
5714       {
5715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5716       };
5717     } catch (std::exception& e) {
5718       {
5719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5720       };
5721     } catch (...) {
5722       {
5723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5724       };
5725     }
5726   }
5727   jresult = (void *)result;
5728   return jresult;
5729 }
5730
5731
5732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5733   void * jresult ;
5734   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5735   float arg2 ;
5736   Dali::Vector3 *result = 0 ;
5737
5738   arg1 = (Dali::Vector3 *)jarg1;
5739   arg2 = (float)jarg2;
5740   {
5741     try {
5742       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5743     } catch (std::out_of_range& e) {
5744       {
5745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (std::exception& e) {
5748       {
5749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5750       };
5751     } catch (...) {
5752       {
5753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5754       };
5755     }
5756   }
5757   jresult = (void *)result;
5758   return jresult;
5759 }
5760
5761
5762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5763   void * jresult ;
5764   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5765   Dali::Vector3 result;
5766
5767   arg1 = (Dali::Vector3 *)jarg1;
5768   {
5769     try {
5770       result = ((Dali::Vector3 const *)arg1)->operator -();
5771     } catch (std::out_of_range& e) {
5772       {
5773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5774       };
5775     } catch (std::exception& e) {
5776       {
5777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5778       };
5779     } catch (...) {
5780       {
5781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5782       };
5783     }
5784   }
5785   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5786   return jresult;
5787 }
5788
5789
5790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5791   unsigned int jresult ;
5792   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5793   Dali::Vector3 *arg2 = 0 ;
5794   bool result;
5795
5796   arg1 = (Dali::Vector3 *)jarg1;
5797   arg2 = (Dali::Vector3 *)jarg2;
5798   if (!arg2) {
5799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5800     return 0;
5801   }
5802   {
5803     try {
5804       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5805     } catch (std::out_of_range& e) {
5806       {
5807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5808       };
5809     } catch (std::exception& e) {
5810       {
5811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5812       };
5813     } catch (...) {
5814       {
5815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5816       };
5817     }
5818   }
5819   jresult = result;
5820   return jresult;
5821 }
5822
5823
5824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5825   unsigned int jresult ;
5826   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5827   Dali::Vector3 *arg2 = 0 ;
5828   bool result;
5829
5830   arg1 = (Dali::Vector3 *)jarg1;
5831   arg2 = (Dali::Vector3 *)jarg2;
5832   if (!arg2) {
5833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5834     return 0;
5835   }
5836   {
5837     try {
5838       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5839     } catch (std::out_of_range& e) {
5840       {
5841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5842       };
5843     } catch (std::exception& e) {
5844       {
5845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5846       };
5847     } catch (...) {
5848       {
5849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5850       };
5851     }
5852   }
5853   jresult = result;
5854   return jresult;
5855 }
5856
5857
5858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5859   float jresult ;
5860   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5861   unsigned int arg2 ;
5862   float *result = 0 ;
5863
5864   arg1 = (Dali::Vector3 *)jarg1;
5865   arg2 = (unsigned int)jarg2;
5866   {
5867     try {
5868       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5869     } catch (std::out_of_range& e) {
5870       {
5871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5872       };
5873     } catch (std::exception& e) {
5874       {
5875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5876       };
5877     } catch (...) {
5878       {
5879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5880       };
5881     }
5882   }
5883   jresult = *result;
5884   return jresult;
5885 }
5886
5887
5888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5889   float jresult ;
5890   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5891   Dali::Vector3 *arg2 = 0 ;
5892   float result;
5893
5894   arg1 = (Dali::Vector3 *)jarg1;
5895   arg2 = (Dali::Vector3 *)jarg2;
5896   if (!arg2) {
5897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5898     return 0;
5899   }
5900   {
5901     try {
5902       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5903     } catch (std::out_of_range& e) {
5904       {
5905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5906       };
5907     } catch (std::exception& e) {
5908       {
5909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5910       };
5911     } catch (...) {
5912       {
5913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5914       };
5915     }
5916   }
5917   jresult = result;
5918   return jresult;
5919 }
5920
5921
5922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5923   void * jresult ;
5924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5925   Dali::Vector3 *arg2 = 0 ;
5926   Dali::Vector3 result;
5927
5928   arg1 = (Dali::Vector3 *)jarg1;
5929   arg2 = (Dali::Vector3 *)jarg2;
5930   if (!arg2) {
5931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5932     return 0;
5933   }
5934   {
5935     try {
5936       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5937     } catch (std::out_of_range& e) {
5938       {
5939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (std::exception& e) {
5942       {
5943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5944       };
5945     } catch (...) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5948       };
5949     }
5950   }
5951   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5952   return jresult;
5953 }
5954
5955
5956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5957   float jresult ;
5958   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5959   float result;
5960
5961   arg1 = (Dali::Vector3 *)jarg1;
5962   {
5963     try {
5964       result = (float)((Dali::Vector3 const *)arg1)->Length();
5965     } catch (std::out_of_range& e) {
5966       {
5967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5968       };
5969     } catch (std::exception& e) {
5970       {
5971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5972       };
5973     } catch (...) {
5974       {
5975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5976       };
5977     }
5978   }
5979   jresult = result;
5980   return jresult;
5981 }
5982
5983
5984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5985   float jresult ;
5986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5987   float result;
5988
5989   arg1 = (Dali::Vector3 *)jarg1;
5990   {
5991     try {
5992       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5993     } catch (std::out_of_range& e) {
5994       {
5995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5996       };
5997     } catch (std::exception& e) {
5998       {
5999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6000       };
6001     } catch (...) {
6002       {
6003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6004       };
6005     }
6006   }
6007   jresult = result;
6008   return jresult;
6009 }
6010
6011
6012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6013   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6014
6015   arg1 = (Dali::Vector3 *)jarg1;
6016   {
6017     try {
6018       (arg1)->Normalize();
6019     } catch (std::out_of_range& e) {
6020       {
6021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6022       };
6023     } catch (std::exception& e) {
6024       {
6025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6030       };
6031     }
6032   }
6033 }
6034
6035
6036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6037   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6038   Dali::Vector3 *arg2 = 0 ;
6039   Dali::Vector3 *arg3 = 0 ;
6040
6041   arg1 = (Dali::Vector3 *)jarg1;
6042   arg2 = (Dali::Vector3 *)jarg2;
6043   if (!arg2) {
6044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6045     return ;
6046   }
6047   arg3 = (Dali::Vector3 *)jarg3;
6048   if (!arg3) {
6049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6050     return ;
6051   }
6052   {
6053     try {
6054       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6055     } catch (std::out_of_range& e) {
6056       {
6057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6058       };
6059     } catch (std::exception& e) {
6060       {
6061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6062       };
6063     } catch (...) {
6064       {
6065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6066       };
6067     }
6068   }
6069 }
6070
6071
6072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6073   void * jresult ;
6074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6075   float *result = 0 ;
6076
6077   arg1 = (Dali::Vector3 *)jarg1;
6078   {
6079     try {
6080       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6081     } catch (std::out_of_range& e) {
6082       {
6083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6084       };
6085     } catch (std::exception& e) {
6086       {
6087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6088       };
6089     } catch (...) {
6090       {
6091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6092       };
6093     }
6094   }
6095   jresult = (void *)result;
6096   return jresult;
6097 }
6098
6099
6100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6101   void * jresult ;
6102   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6103   Dali::Vector2 *result = 0 ;
6104
6105   arg1 = (Dali::Vector3 *)jarg1;
6106   {
6107     try {
6108       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6109     } catch (std::out_of_range& e) {
6110       {
6111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6112       };
6113     } catch (std::exception& e) {
6114       {
6115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6116       };
6117     } catch (...) {
6118       {
6119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6120       };
6121     }
6122   }
6123   jresult = (void *)result;
6124   return jresult;
6125 }
6126
6127
6128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6129   void * jresult ;
6130   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6131   Dali::Vector2 *result = 0 ;
6132
6133   arg1 = (Dali::Vector3 *)jarg1;
6134   {
6135     try {
6136       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6137     } catch (std::out_of_range& e) {
6138       {
6139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6140       };
6141     } catch (std::exception& e) {
6142       {
6143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6144       };
6145     } catch (...) {
6146       {
6147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6148       };
6149     }
6150   }
6151   jresult = (void *)result;
6152   return jresult;
6153 }
6154
6155
6156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6157   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6158   float arg2 ;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   arg2 = (float)jarg2;
6162   if (arg1) (arg1)->x = arg2;
6163 }
6164
6165
6166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6167   float jresult ;
6168   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6169   float result;
6170
6171   arg1 = (Dali::Vector3 *)jarg1;
6172   result = (float) ((arg1)->x);
6173   jresult = result;
6174   return jresult;
6175 }
6176
6177
6178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6179   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6180   float arg2 ;
6181
6182   arg1 = (Dali::Vector3 *)jarg1;
6183   arg2 = (float)jarg2;
6184   if (arg1) (arg1)->width = arg2;
6185 }
6186
6187
6188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6189   float jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   float result;
6192
6193   arg1 = (Dali::Vector3 *)jarg1;
6194   result = (float) ((arg1)->width);
6195   jresult = result;
6196   return jresult;
6197 }
6198
6199
6200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6201   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6202   float arg2 ;
6203
6204   arg1 = (Dali::Vector3 *)jarg1;
6205   arg2 = (float)jarg2;
6206   if (arg1) (arg1)->r = arg2;
6207 }
6208
6209
6210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6211   float jresult ;
6212   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6213   float result;
6214
6215   arg1 = (Dali::Vector3 *)jarg1;
6216   result = (float) ((arg1)->r);
6217   jresult = result;
6218   return jresult;
6219 }
6220
6221
6222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6223   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6224   float arg2 ;
6225
6226   arg1 = (Dali::Vector3 *)jarg1;
6227   arg2 = (float)jarg2;
6228   if (arg1) (arg1)->y = arg2;
6229 }
6230
6231
6232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6233   float jresult ;
6234   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6235   float result;
6236
6237   arg1 = (Dali::Vector3 *)jarg1;
6238   result = (float) ((arg1)->y);
6239   jresult = result;
6240   return jresult;
6241 }
6242
6243
6244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6245   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6246   float arg2 ;
6247
6248   arg1 = (Dali::Vector3 *)jarg1;
6249   arg2 = (float)jarg2;
6250   if (arg1) (arg1)->height = arg2;
6251 }
6252
6253
6254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6255   float jresult ;
6256   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6257   float result;
6258
6259   arg1 = (Dali::Vector3 *)jarg1;
6260   result = (float) ((arg1)->height);
6261   jresult = result;
6262   return jresult;
6263 }
6264
6265
6266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6267   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6268   float arg2 ;
6269
6270   arg1 = (Dali::Vector3 *)jarg1;
6271   arg2 = (float)jarg2;
6272   if (arg1) (arg1)->g = arg2;
6273 }
6274
6275
6276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6277   float jresult ;
6278   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6279   float result;
6280
6281   arg1 = (Dali::Vector3 *)jarg1;
6282   result = (float) ((arg1)->g);
6283   jresult = result;
6284   return jresult;
6285 }
6286
6287
6288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6289   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6290   float arg2 ;
6291
6292   arg1 = (Dali::Vector3 *)jarg1;
6293   arg2 = (float)jarg2;
6294   if (arg1) (arg1)->z = arg2;
6295 }
6296
6297
6298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6299   float jresult ;
6300   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6301   float result;
6302
6303   arg1 = (Dali::Vector3 *)jarg1;
6304   result = (float) ((arg1)->z);
6305   jresult = result;
6306   return jresult;
6307 }
6308
6309
6310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6311   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6312   float arg2 ;
6313
6314   arg1 = (Dali::Vector3 *)jarg1;
6315   arg2 = (float)jarg2;
6316   if (arg1) (arg1)->depth = arg2;
6317 }
6318
6319
6320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6321   float jresult ;
6322   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6323   float result;
6324
6325   arg1 = (Dali::Vector3 *)jarg1;
6326   result = (float) ((arg1)->depth);
6327   jresult = result;
6328   return jresult;
6329 }
6330
6331
6332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6334   float arg2 ;
6335
6336   arg1 = (Dali::Vector3 *)jarg1;
6337   arg2 = (float)jarg2;
6338   if (arg1) (arg1)->b = arg2;
6339 }
6340
6341
6342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6343   float jresult ;
6344   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6345   float result;
6346
6347   arg1 = (Dali::Vector3 *)jarg1;
6348   result = (float) ((arg1)->b);
6349   jresult = result;
6350   return jresult;
6351 }
6352
6353
6354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6355   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6356
6357   arg1 = (Dali::Vector3 *)jarg1;
6358   {
6359     try {
6360       delete arg1;
6361     } catch (std::out_of_range& e) {
6362       {
6363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6364       };
6365     } catch (std::exception& e) {
6366       {
6367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6368       };
6369     } catch (...) {
6370       {
6371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6372       };
6373     }
6374   }
6375 }
6376
6377
6378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6379   void * jresult ;
6380   Dali::Vector3 *arg1 = 0 ;
6381   Dali::Vector3 *arg2 = 0 ;
6382   Dali::Vector3 result;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   if (!arg1) {
6386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6387     return 0;
6388   }
6389   arg2 = (Dali::Vector3 *)jarg2;
6390   if (!arg2) {
6391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6392     return 0;
6393   }
6394   {
6395     try {
6396       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6397     } catch (std::out_of_range& e) {
6398       {
6399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (std::exception& e) {
6402       {
6403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6404       };
6405     } catch (...) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6408       };
6409     }
6410   }
6411   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6412   return jresult;
6413 }
6414
6415
6416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6417   void * jresult ;
6418   Dali::Vector3 *arg1 = 0 ;
6419   Dali::Vector3 *arg2 = 0 ;
6420   Dali::Vector3 result;
6421
6422   arg1 = (Dali::Vector3 *)jarg1;
6423   if (!arg1) {
6424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6425     return 0;
6426   }
6427   arg2 = (Dali::Vector3 *)jarg2;
6428   if (!arg2) {
6429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6430     return 0;
6431   }
6432   {
6433     try {
6434       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6435     } catch (std::out_of_range& e) {
6436       {
6437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6438       };
6439     } catch (std::exception& e) {
6440       {
6441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6442       };
6443     } catch (...) {
6444       {
6445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6446       };
6447     }
6448   }
6449   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6450   return jresult;
6451 }
6452
6453
6454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6455   void * jresult ;
6456   Dali::Vector3 *arg1 = 0 ;
6457   float *arg2 = 0 ;
6458   float *arg3 = 0 ;
6459   float temp2 ;
6460   float temp3 ;
6461   Dali::Vector3 result;
6462
6463   arg1 = (Dali::Vector3 *)jarg1;
6464   if (!arg1) {
6465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6466     return 0;
6467   }
6468   temp2 = (float)jarg2;
6469   arg2 = &temp2;
6470   temp3 = (float)jarg3;
6471   arg3 = &temp3;
6472   {
6473     try {
6474       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6475     } catch (std::out_of_range& e) {
6476       {
6477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6478       };
6479     } catch (std::exception& e) {
6480       {
6481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6482       };
6483     } catch (...) {
6484       {
6485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6486       };
6487     }
6488   }
6489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6490   return jresult;
6491 }
6492
6493
6494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6495   void * jresult ;
6496   Dali::Vector4 *result = 0 ;
6497
6498   {
6499     try {
6500       result = (Dali::Vector4 *)new Dali::Vector4();
6501     } catch (std::out_of_range& e) {
6502       {
6503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6504       };
6505     } catch (std::exception& e) {
6506       {
6507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6508       };
6509     } catch (...) {
6510       {
6511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6512       };
6513     }
6514   }
6515   jresult = (void *)result;
6516   return jresult;
6517 }
6518
6519
6520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6521   void * jresult ;
6522   float arg1 ;
6523   float arg2 ;
6524   float arg3 ;
6525   float arg4 ;
6526   Dali::Vector4 *result = 0 ;
6527
6528   arg1 = (float)jarg1;
6529   arg2 = (float)jarg2;
6530   arg3 = (float)jarg3;
6531   arg4 = (float)jarg4;
6532   {
6533     try {
6534       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6535     } catch (std::out_of_range& e) {
6536       {
6537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (std::exception& e) {
6540       {
6541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (...) {
6544       {
6545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6546       };
6547     }
6548   }
6549   jresult = (void *)result;
6550   return jresult;
6551 }
6552
6553
6554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6555   void * jresult ;
6556   float *arg1 = (float *) 0 ;
6557   Dali::Vector4 *result = 0 ;
6558
6559   arg1 = jarg1;
6560   {
6561     try {
6562       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6563     } catch (std::out_of_range& e) {
6564       {
6565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6566       };
6567     } catch (std::exception& e) {
6568       {
6569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6570       };
6571     } catch (...) {
6572       {
6573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6574       };
6575     }
6576   }
6577   jresult = (void *)result;
6578
6579
6580   return jresult;
6581 }
6582
6583
6584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6585   void * jresult ;
6586   Dali::Vector2 *arg1 = 0 ;
6587   Dali::Vector4 *result = 0 ;
6588
6589   arg1 = (Dali::Vector2 *)jarg1;
6590   if (!arg1) {
6591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6592     return 0;
6593   }
6594   {
6595     try {
6596       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6597     } catch (std::out_of_range& e) {
6598       {
6599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6600       };
6601     } catch (std::exception& e) {
6602       {
6603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6604       };
6605     } catch (...) {
6606       {
6607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6608       };
6609     }
6610   }
6611   jresult = (void *)result;
6612   return jresult;
6613 }
6614
6615
6616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6617   void * jresult ;
6618   Dali::Vector3 *arg1 = 0 ;
6619   Dali::Vector4 *result = 0 ;
6620
6621   arg1 = (Dali::Vector3 *)jarg1;
6622   if (!arg1) {
6623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6624     return 0;
6625   }
6626   {
6627     try {
6628       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6629     } catch (std::out_of_range& e) {
6630       {
6631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6632       };
6633     } catch (std::exception& e) {
6634       {
6635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6636       };
6637     } catch (...) {
6638       {
6639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6640       };
6641     }
6642   }
6643   jresult = (void *)result;
6644   return jresult;
6645 }
6646
6647
6648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6649   void * jresult ;
6650   Dali::Vector4 *result = 0 ;
6651
6652   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6653   jresult = (void *)result;
6654   return jresult;
6655 }
6656
6657
6658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6659   void * jresult ;
6660   Dali::Vector4 *result = 0 ;
6661
6662   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6663   jresult = (void *)result;
6664   return jresult;
6665 }
6666
6667
6668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6669   void * jresult ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6673   jresult = (void *)result;
6674   return jresult;
6675 }
6676
6677
6678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6679   void * jresult ;
6680   Dali::Vector4 *result = 0 ;
6681
6682   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6683   jresult = (void *)result;
6684   return jresult;
6685 }
6686
6687
6688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6689   void * jresult ;
6690   Dali::Vector4 *result = 0 ;
6691
6692   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6693   jresult = (void *)result;
6694   return jresult;
6695 }
6696
6697
6698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6699   void * jresult ;
6700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6701   float *arg2 = (float *) 0 ;
6702   Dali::Vector4 *result = 0 ;
6703
6704   arg1 = (Dali::Vector4 *)jarg1;
6705   arg2 = jarg2;
6706   {
6707     try {
6708       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6709     } catch (std::out_of_range& e) {
6710       {
6711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6712       };
6713     } catch (std::exception& e) {
6714       {
6715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6716       };
6717     } catch (...) {
6718       {
6719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6720       };
6721     }
6722   }
6723   jresult = (void *)result;
6724
6725
6726   return jresult;
6727 }
6728
6729
6730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6731   void * jresult ;
6732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6733   Dali::Vector2 *arg2 = 0 ;
6734   Dali::Vector4 *result = 0 ;
6735
6736   arg1 = (Dali::Vector4 *)jarg1;
6737   arg2 = (Dali::Vector2 *)jarg2;
6738   if (!arg2) {
6739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6740     return 0;
6741   }
6742   {
6743     try {
6744       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6745     } catch (std::out_of_range& e) {
6746       {
6747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6748       };
6749     } catch (std::exception& e) {
6750       {
6751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6752       };
6753     } catch (...) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6756       };
6757     }
6758   }
6759   jresult = (void *)result;
6760   return jresult;
6761 }
6762
6763
6764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6765   void * jresult ;
6766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6767   Dali::Vector3 *arg2 = 0 ;
6768   Dali::Vector4 *result = 0 ;
6769
6770   arg1 = (Dali::Vector4 *)jarg1;
6771   arg2 = (Dali::Vector3 *)jarg2;
6772   if (!arg2) {
6773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6774     return 0;
6775   }
6776   {
6777     try {
6778       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6779     } catch (std::out_of_range& e) {
6780       {
6781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6782       };
6783     } catch (std::exception& e) {
6784       {
6785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6786       };
6787     } catch (...) {
6788       {
6789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6790       };
6791     }
6792   }
6793   jresult = (void *)result;
6794   return jresult;
6795 }
6796
6797
6798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6799   void * jresult ;
6800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6801   Dali::Vector4 *arg2 = 0 ;
6802   Dali::Vector4 result;
6803
6804   arg1 = (Dali::Vector4 *)jarg1;
6805   arg2 = (Dali::Vector4 *)jarg2;
6806   if (!arg2) {
6807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6808     return 0;
6809   }
6810   {
6811     try {
6812       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6813     } catch (std::out_of_range& e) {
6814       {
6815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6816       };
6817     } catch (std::exception& e) {
6818       {
6819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6820       };
6821     } catch (...) {
6822       {
6823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6824       };
6825     }
6826   }
6827   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6828   return jresult;
6829 }
6830
6831
6832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6833   void * jresult ;
6834   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6835   Dali::Vector4 *arg2 = 0 ;
6836   Dali::Vector4 *result = 0 ;
6837
6838   arg1 = (Dali::Vector4 *)jarg1;
6839   arg2 = (Dali::Vector4 *)jarg2;
6840   if (!arg2) {
6841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6842     return 0;
6843   }
6844   {
6845     try {
6846       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6847     } catch (std::out_of_range& e) {
6848       {
6849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6850       };
6851     } catch (std::exception& e) {
6852       {
6853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6854       };
6855     } catch (...) {
6856       {
6857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6858       };
6859     }
6860   }
6861   jresult = (void *)result;
6862   return jresult;
6863 }
6864
6865
6866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6867   void * jresult ;
6868   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6869   Dali::Vector4 *arg2 = 0 ;
6870   Dali::Vector4 result;
6871
6872   arg1 = (Dali::Vector4 *)jarg1;
6873   arg2 = (Dali::Vector4 *)jarg2;
6874   if (!arg2) {
6875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6876     return 0;
6877   }
6878   {
6879     try {
6880       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6881     } catch (std::out_of_range& e) {
6882       {
6883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6884       };
6885     } catch (std::exception& e) {
6886       {
6887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (...) {
6890       {
6891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6892       };
6893     }
6894   }
6895   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6901   void * jresult ;
6902   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6903   Dali::Vector4 *arg2 = 0 ;
6904   Dali::Vector4 *result = 0 ;
6905
6906   arg1 = (Dali::Vector4 *)jarg1;
6907   arg2 = (Dali::Vector4 *)jarg2;
6908   if (!arg2) {
6909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6910     return 0;
6911   }
6912   {
6913     try {
6914       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6915     } catch (std::out_of_range& e) {
6916       {
6917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6918       };
6919     } catch (std::exception& e) {
6920       {
6921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6922       };
6923     } catch (...) {
6924       {
6925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6926       };
6927     }
6928   }
6929   jresult = (void *)result;
6930   return jresult;
6931 }
6932
6933
6934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6935   void * jresult ;
6936   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6937   Dali::Vector4 *arg2 = 0 ;
6938   Dali::Vector4 result;
6939
6940   arg1 = (Dali::Vector4 *)jarg1;
6941   arg2 = (Dali::Vector4 *)jarg2;
6942   if (!arg2) {
6943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6944     return 0;
6945   }
6946   {
6947     try {
6948       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6949     } catch (std::out_of_range& e) {
6950       {
6951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6952       };
6953     } catch (std::exception& e) {
6954       {
6955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6956       };
6957     } catch (...) {
6958       {
6959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6960       };
6961     }
6962   }
6963   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6964   return jresult;
6965 }
6966
6967
6968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6969   void * jresult ;
6970   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6971   float arg2 ;
6972   Dali::Vector4 result;
6973
6974   arg1 = (Dali::Vector4 *)jarg1;
6975   arg2 = (float)jarg2;
6976   {
6977     try {
6978       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6979     } catch (std::out_of_range& e) {
6980       {
6981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6982       };
6983     } catch (std::exception& e) {
6984       {
6985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6986       };
6987     } catch (...) {
6988       {
6989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6990       };
6991     }
6992   }
6993   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6994   return jresult;
6995 }
6996
6997
6998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6999   void * jresult ;
7000   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7001   Dali::Vector4 *arg2 = 0 ;
7002   Dali::Vector4 *result = 0 ;
7003
7004   arg1 = (Dali::Vector4 *)jarg1;
7005   arg2 = (Dali::Vector4 *)jarg2;
7006   if (!arg2) {
7007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7008     return 0;
7009   }
7010   {
7011     try {
7012       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7013     } catch (std::out_of_range& e) {
7014       {
7015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7016       };
7017     } catch (std::exception& e) {
7018       {
7019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7020       };
7021     } catch (...) {
7022       {
7023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7024       };
7025     }
7026   }
7027   jresult = (void *)result;
7028   return jresult;
7029 }
7030
7031
7032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7033   void * jresult ;
7034   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7035   float arg2 ;
7036   Dali::Vector4 *result = 0 ;
7037
7038   arg1 = (Dali::Vector4 *)jarg1;
7039   arg2 = (float)jarg2;
7040   {
7041     try {
7042       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7043     } catch (std::out_of_range& e) {
7044       {
7045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7046       };
7047     } catch (std::exception& e) {
7048       {
7049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7050       };
7051     } catch (...) {
7052       {
7053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7054       };
7055     }
7056   }
7057   jresult = (void *)result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7063   void * jresult ;
7064   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7065   Dali::Vector4 *arg2 = 0 ;
7066   Dali::Vector4 result;
7067
7068   arg1 = (Dali::Vector4 *)jarg1;
7069   arg2 = (Dali::Vector4 *)jarg2;
7070   if (!arg2) {
7071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7072     return 0;
7073   }
7074   {
7075     try {
7076       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7077     } catch (std::out_of_range& e) {
7078       {
7079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7080       };
7081     } catch (std::exception& e) {
7082       {
7083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7084       };
7085     } catch (...) {
7086       {
7087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7088       };
7089     }
7090   }
7091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7092   return jresult;
7093 }
7094
7095
7096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7097   void * jresult ;
7098   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7099   float arg2 ;
7100   Dali::Vector4 result;
7101
7102   arg1 = (Dali::Vector4 *)jarg1;
7103   arg2 = (float)jarg2;
7104   {
7105     try {
7106       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7107     } catch (std::out_of_range& e) {
7108       {
7109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7110       };
7111     } catch (std::exception& e) {
7112       {
7113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7114       };
7115     } catch (...) {
7116       {
7117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7118       };
7119     }
7120   }
7121   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7122   return jresult;
7123 }
7124
7125
7126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7127   void * jresult ;
7128   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7129   Dali::Vector4 *arg2 = 0 ;
7130   Dali::Vector4 *result = 0 ;
7131
7132   arg1 = (Dali::Vector4 *)jarg1;
7133   arg2 = (Dali::Vector4 *)jarg2;
7134   if (!arg2) {
7135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7136     return 0;
7137   }
7138   {
7139     try {
7140       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7141     } catch (std::out_of_range& e) {
7142       {
7143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7144       };
7145     } catch (std::exception& e) {
7146       {
7147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7148       };
7149     } catch (...) {
7150       {
7151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7152       };
7153     }
7154   }
7155   jresult = (void *)result;
7156   return jresult;
7157 }
7158
7159
7160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7161   void * jresult ;
7162   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7163   float arg2 ;
7164   Dali::Vector4 *result = 0 ;
7165
7166   arg1 = (Dali::Vector4 *)jarg1;
7167   arg2 = (float)jarg2;
7168   {
7169     try {
7170       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7171     } catch (std::out_of_range& e) {
7172       {
7173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (std::exception& e) {
7176       {
7177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7178       };
7179     } catch (...) {
7180       {
7181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7182       };
7183     }
7184   }
7185   jresult = (void *)result;
7186   return jresult;
7187 }
7188
7189
7190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7191   void * jresult ;
7192   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7193   Dali::Vector4 result;
7194
7195   arg1 = (Dali::Vector4 *)jarg1;
7196   {
7197     try {
7198       result = ((Dali::Vector4 const *)arg1)->operator -();
7199     } catch (std::out_of_range& e) {
7200       {
7201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7202       };
7203     } catch (std::exception& e) {
7204       {
7205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7206       };
7207     } catch (...) {
7208       {
7209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7210       };
7211     }
7212   }
7213   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7214   return jresult;
7215 }
7216
7217
7218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7219   unsigned int jresult ;
7220   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7221   Dali::Vector4 *arg2 = 0 ;
7222   bool result;
7223
7224   arg1 = (Dali::Vector4 *)jarg1;
7225   arg2 = (Dali::Vector4 *)jarg2;
7226   if (!arg2) {
7227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7228     return 0;
7229   }
7230   {
7231     try {
7232       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7233     } catch (std::out_of_range& e) {
7234       {
7235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7236       };
7237     } catch (std::exception& e) {
7238       {
7239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7240       };
7241     } catch (...) {
7242       {
7243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7244       };
7245     }
7246   }
7247   jresult = result;
7248   return jresult;
7249 }
7250
7251
7252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7253   unsigned int jresult ;
7254   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7255   Dali::Vector4 *arg2 = 0 ;
7256   bool result;
7257
7258   arg1 = (Dali::Vector4 *)jarg1;
7259   arg2 = (Dali::Vector4 *)jarg2;
7260   if (!arg2) {
7261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7262     return 0;
7263   }
7264   {
7265     try {
7266       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7267     } catch (std::out_of_range& e) {
7268       {
7269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7270       };
7271     } catch (std::exception& e) {
7272       {
7273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7274       };
7275     } catch (...) {
7276       {
7277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7278       };
7279     }
7280   }
7281   jresult = result;
7282   return jresult;
7283 }
7284
7285
7286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7287   float jresult ;
7288   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7289   unsigned int arg2 ;
7290   float *result = 0 ;
7291
7292   arg1 = (Dali::Vector4 *)jarg1;
7293   arg2 = (unsigned int)jarg2;
7294   {
7295     try {
7296       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7297     } catch (std::out_of_range& e) {
7298       {
7299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7300       };
7301     } catch (std::exception& e) {
7302       {
7303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7304       };
7305     } catch (...) {
7306       {
7307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7308       };
7309     }
7310   }
7311   jresult = *result;
7312   return jresult;
7313 }
7314
7315
7316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7317   float jresult ;
7318   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7319   Dali::Vector3 *arg2 = 0 ;
7320   float result;
7321
7322   arg1 = (Dali::Vector4 *)jarg1;
7323   arg2 = (Dali::Vector3 *)jarg2;
7324   if (!arg2) {
7325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7326     return 0;
7327   }
7328   {
7329     try {
7330       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7331     } catch (std::out_of_range& e) {
7332       {
7333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7334       };
7335     } catch (std::exception& e) {
7336       {
7337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7338       };
7339     } catch (...) {
7340       {
7341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7342       };
7343     }
7344   }
7345   jresult = result;
7346   return jresult;
7347 }
7348
7349
7350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7351   float jresult ;
7352   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7353   Dali::Vector4 *arg2 = 0 ;
7354   float result;
7355
7356   arg1 = (Dali::Vector4 *)jarg1;
7357   arg2 = (Dali::Vector4 *)jarg2;
7358   if (!arg2) {
7359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7360     return 0;
7361   }
7362   {
7363     try {
7364       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7365     } catch (std::out_of_range& e) {
7366       {
7367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7368       };
7369     } catch (std::exception& e) {
7370       {
7371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7372       };
7373     } catch (...) {
7374       {
7375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7376       };
7377     }
7378   }
7379   jresult = result;
7380   return jresult;
7381 }
7382
7383
7384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7385   float jresult ;
7386   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7387   Dali::Vector4 *arg2 = 0 ;
7388   float result;
7389
7390   arg1 = (Dali::Vector4 *)jarg1;
7391   arg2 = (Dali::Vector4 *)jarg2;
7392   if (!arg2) {
7393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7394     return 0;
7395   }
7396   {
7397     try {
7398       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7399     } catch (std::out_of_range& e) {
7400       {
7401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7402       };
7403     } catch (std::exception& e) {
7404       {
7405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7406       };
7407     } catch (...) {
7408       {
7409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7410       };
7411     }
7412   }
7413   jresult = result;
7414   return jresult;
7415 }
7416
7417
7418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7419   void * jresult ;
7420   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7421   Dali::Vector4 *arg2 = 0 ;
7422   Dali::Vector4 result;
7423
7424   arg1 = (Dali::Vector4 *)jarg1;
7425   arg2 = (Dali::Vector4 *)jarg2;
7426   if (!arg2) {
7427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7428     return 0;
7429   }
7430   {
7431     try {
7432       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7433     } catch (std::out_of_range& e) {
7434       {
7435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7436       };
7437     } catch (std::exception& e) {
7438       {
7439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7440       };
7441     } catch (...) {
7442       {
7443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7444       };
7445     }
7446   }
7447   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7448   return jresult;
7449 }
7450
7451
7452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7453   float jresult ;
7454   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7455   float result;
7456
7457   arg1 = (Dali::Vector4 *)jarg1;
7458   {
7459     try {
7460       result = (float)((Dali::Vector4 const *)arg1)->Length();
7461     } catch (std::out_of_range& e) {
7462       {
7463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7464       };
7465     } catch (std::exception& e) {
7466       {
7467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7468       };
7469     } catch (...) {
7470       {
7471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7472       };
7473     }
7474   }
7475   jresult = result;
7476   return jresult;
7477 }
7478
7479
7480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7481   float jresult ;
7482   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7483   float result;
7484
7485   arg1 = (Dali::Vector4 *)jarg1;
7486   {
7487     try {
7488       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7489     } catch (std::out_of_range& e) {
7490       {
7491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7492       };
7493     } catch (std::exception& e) {
7494       {
7495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7496       };
7497     } catch (...) {
7498       {
7499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7500       };
7501     }
7502   }
7503   jresult = result;
7504   return jresult;
7505 }
7506
7507
7508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7509   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7510
7511   arg1 = (Dali::Vector4 *)jarg1;
7512   {
7513     try {
7514       (arg1)->Normalize();
7515     } catch (std::out_of_range& e) {
7516       {
7517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7518       };
7519     } catch (std::exception& e) {
7520       {
7521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7522       };
7523     } catch (...) {
7524       {
7525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7526       };
7527     }
7528   }
7529 }
7530
7531
7532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7533   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7534   Dali::Vector4 *arg2 = 0 ;
7535   Dali::Vector4 *arg3 = 0 ;
7536
7537   arg1 = (Dali::Vector4 *)jarg1;
7538   arg2 = (Dali::Vector4 *)jarg2;
7539   if (!arg2) {
7540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7541     return ;
7542   }
7543   arg3 = (Dali::Vector4 *)jarg3;
7544   if (!arg3) {
7545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7546     return ;
7547   }
7548   {
7549     try {
7550       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7551     } catch (std::out_of_range& e) {
7552       {
7553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7554       };
7555     } catch (std::exception& e) {
7556       {
7557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7558       };
7559     } catch (...) {
7560       {
7561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7562       };
7563     }
7564   }
7565 }
7566
7567
7568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7569   void * jresult ;
7570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7571   float *result = 0 ;
7572
7573   arg1 = (Dali::Vector4 *)jarg1;
7574   {
7575     try {
7576       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7577     } catch (std::out_of_range& e) {
7578       {
7579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7580       };
7581     } catch (std::exception& e) {
7582       {
7583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7584       };
7585     } catch (...) {
7586       {
7587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7588       };
7589     }
7590   }
7591   jresult = (void *)result;
7592   return jresult;
7593 }
7594
7595
7596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7598   float arg2 ;
7599
7600   arg1 = (Dali::Vector4 *)jarg1;
7601   arg2 = (float)jarg2;
7602   if (arg1) (arg1)->x = arg2;
7603 }
7604
7605
7606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7607   float jresult ;
7608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7609   float result;
7610
7611   arg1 = (Dali::Vector4 *)jarg1;
7612   result = (float) ((arg1)->x);
7613   jresult = result;
7614   return jresult;
7615 }
7616
7617
7618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7620   float arg2 ;
7621
7622   arg1 = (Dali::Vector4 *)jarg1;
7623   arg2 = (float)jarg2;
7624   if (arg1) (arg1)->r = arg2;
7625 }
7626
7627
7628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7629   float jresult ;
7630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7631   float result;
7632
7633   arg1 = (Dali::Vector4 *)jarg1;
7634   result = (float) ((arg1)->r);
7635   jresult = result;
7636   return jresult;
7637 }
7638
7639
7640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7642   float arg2 ;
7643
7644   arg1 = (Dali::Vector4 *)jarg1;
7645   arg2 = (float)jarg2;
7646   if (arg1) (arg1)->s = arg2;
7647 }
7648
7649
7650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7651   float jresult ;
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   float result;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   result = (float) ((arg1)->s);
7657   jresult = result;
7658   return jresult;
7659 }
7660
7661
7662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7664   float arg2 ;
7665
7666   arg1 = (Dali::Vector4 *)jarg1;
7667   arg2 = (float)jarg2;
7668   if (arg1) (arg1)->y = arg2;
7669 }
7670
7671
7672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7673   float jresult ;
7674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7675   float result;
7676
7677   arg1 = (Dali::Vector4 *)jarg1;
7678   result = (float) ((arg1)->y);
7679   jresult = result;
7680   return jresult;
7681 }
7682
7683
7684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7686   float arg2 ;
7687
7688   arg1 = (Dali::Vector4 *)jarg1;
7689   arg2 = (float)jarg2;
7690   if (arg1) (arg1)->g = arg2;
7691 }
7692
7693
7694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7695   float jresult ;
7696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7697   float result;
7698
7699   arg1 = (Dali::Vector4 *)jarg1;
7700   result = (float) ((arg1)->g);
7701   jresult = result;
7702   return jresult;
7703 }
7704
7705
7706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7708   float arg2 ;
7709
7710   arg1 = (Dali::Vector4 *)jarg1;
7711   arg2 = (float)jarg2;
7712   if (arg1) (arg1)->t = arg2;
7713 }
7714
7715
7716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7717   float jresult ;
7718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7719   float result;
7720
7721   arg1 = (Dali::Vector4 *)jarg1;
7722   result = (float) ((arg1)->t);
7723   jresult = result;
7724   return jresult;
7725 }
7726
7727
7728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7730   float arg2 ;
7731
7732   arg1 = (Dali::Vector4 *)jarg1;
7733   arg2 = (float)jarg2;
7734   if (arg1) (arg1)->z = arg2;
7735 }
7736
7737
7738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7739   float jresult ;
7740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7741   float result;
7742
7743   arg1 = (Dali::Vector4 *)jarg1;
7744   result = (float) ((arg1)->z);
7745   jresult = result;
7746   return jresult;
7747 }
7748
7749
7750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7752   float arg2 ;
7753
7754   arg1 = (Dali::Vector4 *)jarg1;
7755   arg2 = (float)jarg2;
7756   if (arg1) (arg1)->b = arg2;
7757 }
7758
7759
7760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7761   float jresult ;
7762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7763   float result;
7764
7765   arg1 = (Dali::Vector4 *)jarg1;
7766   result = (float) ((arg1)->b);
7767   jresult = result;
7768   return jresult;
7769 }
7770
7771
7772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7773   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7774   float arg2 ;
7775
7776   arg1 = (Dali::Vector4 *)jarg1;
7777   arg2 = (float)jarg2;
7778   if (arg1) (arg1)->p = arg2;
7779 }
7780
7781
7782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7783   float jresult ;
7784   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7785   float result;
7786
7787   arg1 = (Dali::Vector4 *)jarg1;
7788   result = (float) ((arg1)->p);
7789   jresult = result;
7790   return jresult;
7791 }
7792
7793
7794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7796   float arg2 ;
7797
7798   arg1 = (Dali::Vector4 *)jarg1;
7799   arg2 = (float)jarg2;
7800   if (arg1) (arg1)->w = arg2;
7801 }
7802
7803
7804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7805   float jresult ;
7806   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7807   float result;
7808
7809   arg1 = (Dali::Vector4 *)jarg1;
7810   result = (float) ((arg1)->w);
7811   jresult = result;
7812   return jresult;
7813 }
7814
7815
7816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7817   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7818   float arg2 ;
7819
7820   arg1 = (Dali::Vector4 *)jarg1;
7821   arg2 = (float)jarg2;
7822   if (arg1) (arg1)->a = arg2;
7823 }
7824
7825
7826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7827   float jresult ;
7828   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7829   float result;
7830
7831   arg1 = (Dali::Vector4 *)jarg1;
7832   result = (float) ((arg1)->a);
7833   jresult = result;
7834   return jresult;
7835 }
7836
7837
7838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7839   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7840   float arg2 ;
7841
7842   arg1 = (Dali::Vector4 *)jarg1;
7843   arg2 = (float)jarg2;
7844   if (arg1) (arg1)->q = arg2;
7845 }
7846
7847
7848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7849   float jresult ;
7850   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7851   float result;
7852
7853   arg1 = (Dali::Vector4 *)jarg1;
7854   result = (float) ((arg1)->q);
7855   jresult = result;
7856   return jresult;
7857 }
7858
7859
7860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7861   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7862
7863   arg1 = (Dali::Vector4 *)jarg1;
7864   {
7865     try {
7866       delete arg1;
7867     } catch (std::out_of_range& e) {
7868       {
7869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7870       };
7871     } catch (std::exception& e) {
7872       {
7873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7874       };
7875     } catch (...) {
7876       {
7877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7878       };
7879     }
7880   }
7881 }
7882
7883
7884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7885   void * jresult ;
7886   Dali::Vector4 *arg1 = 0 ;
7887   Dali::Vector4 *arg2 = 0 ;
7888   Dali::Vector4 result;
7889
7890   arg1 = (Dali::Vector4 *)jarg1;
7891   if (!arg1) {
7892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7893     return 0;
7894   }
7895   arg2 = (Dali::Vector4 *)jarg2;
7896   if (!arg2) {
7897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7898     return 0;
7899   }
7900   {
7901     try {
7902       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7903     } catch (std::out_of_range& e) {
7904       {
7905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7906       };
7907     } catch (std::exception& e) {
7908       {
7909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7910       };
7911     } catch (...) {
7912       {
7913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7914       };
7915     }
7916   }
7917   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7918   return jresult;
7919 }
7920
7921
7922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7923   void * jresult ;
7924   Dali::Vector4 *arg1 = 0 ;
7925   Dali::Vector4 *arg2 = 0 ;
7926   Dali::Vector4 result;
7927
7928   arg1 = (Dali::Vector4 *)jarg1;
7929   if (!arg1) {
7930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7931     return 0;
7932   }
7933   arg2 = (Dali::Vector4 *)jarg2;
7934   if (!arg2) {
7935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7936     return 0;
7937   }
7938   {
7939     try {
7940       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7941     } catch (std::out_of_range& e) {
7942       {
7943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7944       };
7945     } catch (std::exception& e) {
7946       {
7947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7948       };
7949     } catch (...) {
7950       {
7951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7952       };
7953     }
7954   }
7955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7956   return jresult;
7957 }
7958
7959
7960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7961   void * jresult ;
7962   Dali::Vector4 *arg1 = 0 ;
7963   float *arg2 = 0 ;
7964   float *arg3 = 0 ;
7965   float temp2 ;
7966   float temp3 ;
7967   Dali::Vector4 result;
7968
7969   arg1 = (Dali::Vector4 *)jarg1;
7970   if (!arg1) {
7971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7972     return 0;
7973   }
7974   temp2 = (float)jarg2;
7975   arg2 = &temp2;
7976   temp3 = (float)jarg3;
7977   arg3 = &temp3;
7978   {
7979     try {
7980       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7981     } catch (std::out_of_range& e) {
7982       {
7983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7984       };
7985     } catch (std::exception& e) {
7986       {
7987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7988       };
7989     } catch (...) {
7990       {
7991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7992       };
7993     }
7994   }
7995   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7996   return jresult;
7997 }
7998
7999
8000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8001   void * jresult ;
8002   Dali::Uint16Pair *result = 0 ;
8003
8004   {
8005     try {
8006       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8007     } catch (std::out_of_range& e) {
8008       {
8009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8010       };
8011     } catch (std::exception& e) {
8012       {
8013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8014       };
8015     } catch (...) {
8016       {
8017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8018       };
8019     }
8020   }
8021   jresult = (void *)result;
8022   return jresult;
8023 }
8024
8025
8026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8027   void * jresult ;
8028   uint32_t arg1 ;
8029   uint32_t arg2 ;
8030   Dali::Uint16Pair *result = 0 ;
8031
8032   arg1 = (uint32_t)jarg1;
8033   arg2 = (uint32_t)jarg2;
8034   {
8035     try {
8036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8037     } catch (std::out_of_range& e) {
8038       {
8039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8040       };
8041     } catch (std::exception& e) {
8042       {
8043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (...) {
8046       {
8047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8048       };
8049     }
8050   }
8051   jresult = (void *)result;
8052   return jresult;
8053 }
8054
8055
8056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8057   void * jresult ;
8058   Dali::Uint16Pair *arg1 = 0 ;
8059   Dali::Uint16Pair *result = 0 ;
8060
8061   arg1 = (Dali::Uint16Pair *)jarg1;
8062   if (!arg1) {
8063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8064     return 0;
8065   }
8066   {
8067     try {
8068       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8069     } catch (std::out_of_range& e) {
8070       {
8071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8072       };
8073     } catch (std::exception& e) {
8074       {
8075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8076       };
8077     } catch (...) {
8078       {
8079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8080       };
8081     }
8082   }
8083   jresult = (void *)result;
8084   return jresult;
8085 }
8086
8087
8088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8089   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8090   uint16_t arg2 ;
8091
8092   arg1 = (Dali::Uint16Pair *)jarg1;
8093   arg2 = (uint16_t)jarg2;
8094   {
8095     try {
8096       (arg1)->SetWidth(arg2);
8097     } catch (std::out_of_range& e) {
8098       {
8099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8100       };
8101     } catch (std::exception& e) {
8102       {
8103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8104       };
8105     } catch (...) {
8106       {
8107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8108       };
8109     }
8110   }
8111 }
8112
8113
8114 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8115   unsigned short jresult ;
8116   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8117   uint16_t result;
8118
8119   arg1 = (Dali::Uint16Pair *)jarg1;
8120   {
8121     try {
8122       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8123     } catch (std::out_of_range& e) {
8124       {
8125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8126       };
8127     } catch (std::exception& e) {
8128       {
8129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8130       };
8131     } catch (...) {
8132       {
8133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8134       };
8135     }
8136   }
8137   jresult = result;
8138   return jresult;
8139 }
8140
8141
8142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8143   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8144   uint16_t arg2 ;
8145
8146   arg1 = (Dali::Uint16Pair *)jarg1;
8147   arg2 = (uint16_t)jarg2;
8148   {
8149     try {
8150       (arg1)->SetHeight(arg2);
8151     } catch (std::out_of_range& e) {
8152       {
8153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8154       };
8155     } catch (std::exception& e) {
8156       {
8157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8158       };
8159     } catch (...) {
8160       {
8161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8162       };
8163     }
8164   }
8165 }
8166
8167
8168 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8169   unsigned short jresult ;
8170   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8171   uint16_t result;
8172
8173   arg1 = (Dali::Uint16Pair *)jarg1;
8174   {
8175     try {
8176       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8177     } catch (std::out_of_range& e) {
8178       {
8179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8180       };
8181     } catch (std::exception& e) {
8182       {
8183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8184       };
8185     } catch (...) {
8186       {
8187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8188       };
8189     }
8190   }
8191   jresult = result;
8192   return jresult;
8193 }
8194
8195
8196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8197   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8198   uint16_t arg2 ;
8199
8200   arg1 = (Dali::Uint16Pair *)jarg1;
8201   arg2 = (uint16_t)jarg2;
8202   {
8203     try {
8204       (arg1)->SetX(arg2);
8205     } catch (std::out_of_range& e) {
8206       {
8207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8208       };
8209     } catch (std::exception& e) {
8210       {
8211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8212       };
8213     } catch (...) {
8214       {
8215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8216       };
8217     }
8218   }
8219 }
8220
8221
8222 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8223   unsigned short jresult ;
8224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8225   uint16_t result;
8226
8227   arg1 = (Dali::Uint16Pair *)jarg1;
8228   {
8229     try {
8230       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8231     } catch (std::out_of_range& e) {
8232       {
8233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8234       };
8235     } catch (std::exception& e) {
8236       {
8237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8238       };
8239     } catch (...) {
8240       {
8241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8242       };
8243     }
8244   }
8245   jresult = result;
8246   return jresult;
8247 }
8248
8249
8250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8251   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8252   uint16_t arg2 ;
8253
8254   arg1 = (Dali::Uint16Pair *)jarg1;
8255   arg2 = (uint16_t)jarg2;
8256   {
8257     try {
8258       (arg1)->SetY(arg2);
8259     } catch (std::out_of_range& e) {
8260       {
8261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8262       };
8263     } catch (std::exception& e) {
8264       {
8265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8266       };
8267     } catch (...) {
8268       {
8269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8270       };
8271     }
8272   }
8273 }
8274
8275
8276 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8277   unsigned short jresult ;
8278   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8279   uint16_t result;
8280
8281   arg1 = (Dali::Uint16Pair *)jarg1;
8282   {
8283     try {
8284       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8285     } catch (std::out_of_range& e) {
8286       {
8287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8288       };
8289     } catch (std::exception& e) {
8290       {
8291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8292       };
8293     } catch (...) {
8294       {
8295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8296       };
8297     }
8298   }
8299   jresult = result;
8300   return jresult;
8301 }
8302
8303
8304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8305   void * jresult ;
8306   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8307   Dali::Uint16Pair *arg2 = 0 ;
8308   Dali::Uint16Pair *result = 0 ;
8309
8310   arg1 = (Dali::Uint16Pair *)jarg1;
8311   arg2 = (Dali::Uint16Pair *)jarg2;
8312   if (!arg2) {
8313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8314     return 0;
8315   }
8316   {
8317     try {
8318       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8319     } catch (std::out_of_range& e) {
8320       {
8321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8322       };
8323     } catch (std::exception& e) {
8324       {
8325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8326       };
8327     } catch (...) {
8328       {
8329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8330       };
8331     }
8332   }
8333   jresult = (void *)result;
8334   return jresult;
8335 }
8336
8337
8338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8339   unsigned int jresult ;
8340   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8341   Dali::Uint16Pair *arg2 = 0 ;
8342   bool result;
8343
8344   arg1 = (Dali::Uint16Pair *)jarg1;
8345   arg2 = (Dali::Uint16Pair *)jarg2;
8346   if (!arg2) {
8347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8348     return 0;
8349   }
8350   {
8351     try {
8352       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8353     } catch (std::out_of_range& e) {
8354       {
8355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8356       };
8357     } catch (std::exception& e) {
8358       {
8359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8360       };
8361     } catch (...) {
8362       {
8363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8364       };
8365     }
8366   }
8367   jresult = result;
8368   return jresult;
8369 }
8370
8371
8372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8373   unsigned int jresult ;
8374   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8375   Dali::Uint16Pair *arg2 = 0 ;
8376   bool result;
8377
8378   arg1 = (Dali::Uint16Pair *)jarg1;
8379   arg2 = (Dali::Uint16Pair *)jarg2;
8380   if (!arg2) {
8381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8382     return 0;
8383   }
8384   {
8385     try {
8386       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8387     } catch (std::out_of_range& e) {
8388       {
8389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8390       };
8391     } catch (std::exception& e) {
8392       {
8393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8394       };
8395     } catch (...) {
8396       {
8397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8398       };
8399     }
8400   }
8401   jresult = result;
8402   return jresult;
8403 }
8404
8405
8406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8407   unsigned int jresult ;
8408   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8409   Dali::Uint16Pair *arg2 = 0 ;
8410   bool result;
8411
8412   arg1 = (Dali::Uint16Pair *)jarg1;
8413   arg2 = (Dali::Uint16Pair *)jarg2;
8414   if (!arg2) {
8415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8416     return 0;
8417   }
8418   {
8419     try {
8420       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8421     } catch (std::out_of_range& e) {
8422       {
8423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8424       };
8425     } catch (std::exception& e) {
8426       {
8427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8428       };
8429     } catch (...) {
8430       {
8431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8432       };
8433     }
8434   }
8435   jresult = result;
8436   return jresult;
8437 }
8438
8439
8440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8441   unsigned int jresult ;
8442   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8443   Dali::Uint16Pair *arg2 = 0 ;
8444   bool result;
8445
8446   arg1 = (Dali::Uint16Pair *)jarg1;
8447   arg2 = (Dali::Uint16Pair *)jarg2;
8448   if (!arg2) {
8449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8450     return 0;
8451   }
8452   {
8453     try {
8454       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8455     } catch (std::out_of_range& e) {
8456       {
8457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8458       };
8459     } catch (std::exception& e) {
8460       {
8461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8462       };
8463     } catch (...) {
8464       {
8465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8466       };
8467     }
8468   }
8469   jresult = result;
8470   return jresult;
8471 }
8472
8473
8474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8476
8477   arg1 = (Dali::Uint16Pair *)jarg1;
8478   {
8479     try {
8480       delete arg1;
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8488       };
8489     } catch (...) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8492       };
8493     }
8494   }
8495 }
8496
8497
8498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8499   void * jresult ;
8500   Dali::Degree *result = 0 ;
8501
8502   {
8503     try {
8504       result = (Dali::Degree *)new Dali::Degree();
8505     } catch (std::out_of_range& e) {
8506       {
8507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8508       };
8509     } catch (std::exception& e) {
8510       {
8511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8512       };
8513     } catch (...) {
8514       {
8515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8516       };
8517     }
8518   }
8519   jresult = (void *)result;
8520   return jresult;
8521 }
8522
8523
8524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8525   void * jresult ;
8526   float arg1 ;
8527   Dali::Degree *result = 0 ;
8528
8529   arg1 = (float)jarg1;
8530   {
8531     try {
8532       result = (Dali::Degree *)new Dali::Degree(arg1);
8533     } catch (std::out_of_range& e) {
8534       {
8535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8536       };
8537     } catch (std::exception& e) {
8538       {
8539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8540       };
8541     } catch (...) {
8542       {
8543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8544       };
8545     }
8546   }
8547   jresult = (void *)result;
8548   return jresult;
8549 }
8550
8551
8552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8553   void * jresult ;
8554   Dali::Radian arg1 ;
8555   Dali::Radian *argp1 ;
8556   Dali::Degree *result = 0 ;
8557
8558   argp1 = (Dali::Radian *)jarg1;
8559   if (!argp1) {
8560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8561     return 0;
8562   }
8563   arg1 = *argp1;
8564   {
8565     try {
8566       result = (Dali::Degree *)new Dali::Degree(arg1);
8567     } catch (std::out_of_range& e) {
8568       {
8569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8570       };
8571     } catch (std::exception& e) {
8572       {
8573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8574       };
8575     } catch (...) {
8576       {
8577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8578       };
8579     }
8580   }
8581   jresult = (void *)result;
8582   return jresult;
8583 }
8584
8585
8586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8587   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8588   float arg2 ;
8589
8590   arg1 = (Dali::Degree *)jarg1;
8591   arg2 = (float)jarg2;
8592   if (arg1) (arg1)->degree = arg2;
8593 }
8594
8595
8596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8597   float jresult ;
8598   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8599   float result;
8600
8601   arg1 = (Dali::Degree *)jarg1;
8602   result = (float) ((arg1)->degree);
8603   jresult = result;
8604   return jresult;
8605 }
8606
8607
8608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8609   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8610
8611   arg1 = (Dali::Degree *)jarg1;
8612   {
8613     try {
8614       delete arg1;
8615     } catch (std::out_of_range& e) {
8616       {
8617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8618       };
8619     } catch (std::exception& e) {
8620       {
8621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8622       };
8623     } catch (...) {
8624       {
8625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8626       };
8627     }
8628   }
8629 }
8630
8631
8632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8633   void * jresult ;
8634   Dali::Radian *result = 0 ;
8635
8636   result = (Dali::Radian *)&Dali::ANGLE_360;
8637   jresult = (void *)result;
8638   return jresult;
8639 }
8640
8641
8642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8643   void * jresult ;
8644   Dali::Radian *result = 0 ;
8645
8646   result = (Dali::Radian *)&Dali::ANGLE_315;
8647   jresult = (void *)result;
8648   return jresult;
8649 }
8650
8651
8652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8653   void * jresult ;
8654   Dali::Radian *result = 0 ;
8655
8656   result = (Dali::Radian *)&Dali::ANGLE_270;
8657   jresult = (void *)result;
8658   return jresult;
8659 }
8660
8661
8662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8663   void * jresult ;
8664   Dali::Radian *result = 0 ;
8665
8666   result = (Dali::Radian *)&Dali::ANGLE_225;
8667   jresult = (void *)result;
8668   return jresult;
8669 }
8670
8671
8672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8673   void * jresult ;
8674   Dali::Radian *result = 0 ;
8675
8676   result = (Dali::Radian *)&Dali::ANGLE_180;
8677   jresult = (void *)result;
8678   return jresult;
8679 }
8680
8681
8682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8683   void * jresult ;
8684   Dali::Radian *result = 0 ;
8685
8686   result = (Dali::Radian *)&Dali::ANGLE_135;
8687   jresult = (void *)result;
8688   return jresult;
8689 }
8690
8691
8692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8693   void * jresult ;
8694   Dali::Radian *result = 0 ;
8695
8696   result = (Dali::Radian *)&Dali::ANGLE_120;
8697   jresult = (void *)result;
8698   return jresult;
8699 }
8700
8701
8702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8703   void * jresult ;
8704   Dali::Radian *result = 0 ;
8705
8706   result = (Dali::Radian *)&Dali::ANGLE_90;
8707   jresult = (void *)result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8713   void * jresult ;
8714   Dali::Radian *result = 0 ;
8715
8716   result = (Dali::Radian *)&Dali::ANGLE_60;
8717   jresult = (void *)result;
8718   return jresult;
8719 }
8720
8721
8722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8723   void * jresult ;
8724   Dali::Radian *result = 0 ;
8725
8726   result = (Dali::Radian *)&Dali::ANGLE_45;
8727   jresult = (void *)result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8733   void * jresult ;
8734   Dali::Radian *result = 0 ;
8735
8736   result = (Dali::Radian *)&Dali::ANGLE_30;
8737   jresult = (void *)result;
8738   return jresult;
8739 }
8740
8741
8742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8743   void * jresult ;
8744   Dali::Radian *result = 0 ;
8745
8746   result = (Dali::Radian *)&Dali::ANGLE_0;
8747   jresult = (void *)result;
8748   return jresult;
8749 }
8750
8751
8752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8753   unsigned int jresult ;
8754   Dali::Degree *arg1 = 0 ;
8755   Dali::Degree *arg2 = 0 ;
8756   bool result;
8757
8758   arg1 = (Dali::Degree *)jarg1;
8759   if (!arg1) {
8760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8761     return 0;
8762   }
8763   arg2 = (Dali::Degree *)jarg2;
8764   if (!arg2) {
8765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8766     return 0;
8767   }
8768   {
8769     try {
8770       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8771     } catch (std::out_of_range& e) {
8772       {
8773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8774       };
8775     } catch (std::exception& e) {
8776       {
8777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8778       };
8779     } catch (...) {
8780       {
8781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8782       };
8783     }
8784   }
8785   jresult = result;
8786   return jresult;
8787 }
8788
8789
8790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8791   unsigned int jresult ;
8792   Dali::Degree *arg1 = 0 ;
8793   Dali::Degree *arg2 = 0 ;
8794   bool result;
8795
8796   arg1 = (Dali::Degree *)jarg1;
8797   if (!arg1) {
8798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8799     return 0;
8800   }
8801   arg2 = (Dali::Degree *)jarg2;
8802   if (!arg2) {
8803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8804     return 0;
8805   }
8806   {
8807     try {
8808       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8809     } catch (std::out_of_range& e) {
8810       {
8811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8812       };
8813     } catch (std::exception& e) {
8814       {
8815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8816       };
8817     } catch (...) {
8818       {
8819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8820       };
8821     }
8822   }
8823   jresult = result;
8824   return jresult;
8825 }
8826
8827
8828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8829   void * jresult ;
8830   Dali::Degree arg1 ;
8831   float arg2 ;
8832   float arg3 ;
8833   Dali::Degree *argp1 ;
8834   Dali::Degree result;
8835
8836   argp1 = (Dali::Degree *)jarg1;
8837   if (!argp1) {
8838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8839     return 0;
8840   }
8841   arg1 = *argp1;
8842   arg2 = (float)jarg2;
8843   arg3 = (float)jarg3;
8844   {
8845     try {
8846       result = Dali::Clamp(arg1,arg2,arg3);
8847     } catch (std::out_of_range& e) {
8848       {
8849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8850       };
8851     } catch (std::exception& e) {
8852       {
8853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8854       };
8855     } catch (...) {
8856       {
8857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8858       };
8859     }
8860   }
8861   jresult = new Dali::Degree((const Dali::Degree &)result);
8862   return jresult;
8863 }
8864
8865
8866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8867   void * jresult ;
8868   Dali::Radian *result = 0 ;
8869
8870   {
8871     try {
8872       result = (Dali::Radian *)new Dali::Radian();
8873     } catch (std::out_of_range& e) {
8874       {
8875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8876       };
8877     } catch (std::exception& e) {
8878       {
8879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8880       };
8881     } catch (...) {
8882       {
8883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8884       };
8885     }
8886   }
8887   jresult = (void *)result;
8888   return jresult;
8889 }
8890
8891
8892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8893   void * jresult ;
8894   float arg1 ;
8895   Dali::Radian *result = 0 ;
8896
8897   arg1 = (float)jarg1;
8898   {
8899     try {
8900       result = (Dali::Radian *)new Dali::Radian(arg1);
8901     } catch (std::out_of_range& e) {
8902       {
8903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8904       };
8905     } catch (std::exception& e) {
8906       {
8907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8908       };
8909     } catch (...) {
8910       {
8911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8912       };
8913     }
8914   }
8915   jresult = (void *)result;
8916   return jresult;
8917 }
8918
8919
8920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8921   void * jresult ;
8922   Dali::Degree arg1 ;
8923   Dali::Degree *argp1 ;
8924   Dali::Radian *result = 0 ;
8925
8926   argp1 = (Dali::Degree *)jarg1;
8927   if (!argp1) {
8928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8929     return 0;
8930   }
8931   arg1 = *argp1;
8932   {
8933     try {
8934       result = (Dali::Radian *)new Dali::Radian(arg1);
8935     } catch (std::out_of_range& e) {
8936       {
8937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8938       };
8939     } catch (std::exception& e) {
8940       {
8941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8942       };
8943     } catch (...) {
8944       {
8945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8946       };
8947     }
8948   }
8949   jresult = (void *)result;
8950   return jresult;
8951 }
8952
8953
8954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8955   void * jresult ;
8956   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8957   float arg2 ;
8958   Dali::Radian *result = 0 ;
8959
8960   arg1 = (Dali::Radian *)jarg1;
8961   arg2 = (float)jarg2;
8962   {
8963     try {
8964       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8965     } catch (std::out_of_range& e) {
8966       {
8967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (std::exception& e) {
8970       {
8971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (...) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8976       };
8977     }
8978   }
8979   jresult = (void *)result;
8980   return jresult;
8981 }
8982
8983
8984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8985   void * jresult ;
8986   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8987   Dali::Degree arg2 ;
8988   Dali::Degree *argp2 ;
8989   Dali::Radian *result = 0 ;
8990
8991   arg1 = (Dali::Radian *)jarg1;
8992   argp2 = (Dali::Degree *)jarg2;
8993   if (!argp2) {
8994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8995     return 0;
8996   }
8997   arg2 = *argp2;
8998   {
8999     try {
9000       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9001     } catch (std::out_of_range& e) {
9002       {
9003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9004       };
9005     } catch (std::exception& e) {
9006       {
9007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9008       };
9009     } catch (...) {
9010       {
9011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9012       };
9013     }
9014   }
9015   jresult = (void *)result;
9016   return jresult;
9017 }
9018
9019
9020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9021   float jresult ;
9022   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9023   float result;
9024
9025   arg1 = (Dali::Radian *)jarg1;
9026   {
9027     try {
9028       result = (float)((Dali::Radian const *)arg1)->operator float();
9029     } catch (std::out_of_range& e) {
9030       {
9031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9032       };
9033     } catch (std::exception& e) {
9034       {
9035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9036       };
9037     } catch (...) {
9038       {
9039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9040       };
9041     }
9042   }
9043   jresult = result;
9044   return jresult;
9045 }
9046
9047
9048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9050   float arg2 ;
9051
9052   arg1 = (Dali::Radian *)jarg1;
9053   arg2 = (float)jarg2;
9054   if (arg1) (arg1)->radian = arg2;
9055 }
9056
9057
9058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9059   float jresult ;
9060   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9061   float result;
9062
9063   arg1 = (Dali::Radian *)jarg1;
9064   result = (float) ((arg1)->radian);
9065   jresult = result;
9066   return jresult;
9067 }
9068
9069
9070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9071   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9072
9073   arg1 = (Dali::Radian *)jarg1;
9074   {
9075     try {
9076       delete arg1;
9077     } catch (std::out_of_range& e) {
9078       {
9079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9080       };
9081     } catch (std::exception& e) {
9082       {
9083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9084       };
9085     } catch (...) {
9086       {
9087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9088       };
9089     }
9090   }
9091 }
9092
9093
9094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9095   unsigned int jresult ;
9096   Dali::Radian arg1 ;
9097   Dali::Radian arg2 ;
9098   Dali::Radian *argp1 ;
9099   Dali::Radian *argp2 ;
9100   bool result;
9101
9102   argp1 = (Dali::Radian *)jarg1;
9103   if (!argp1) {
9104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9105     return 0;
9106   }
9107   arg1 = *argp1;
9108   argp2 = (Dali::Radian *)jarg2;
9109   if (!argp2) {
9110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9111     return 0;
9112   }
9113   arg2 = *argp2;
9114   {
9115     try {
9116       result = (bool)Dali::operator ==(arg1,arg2);
9117     } catch (std::out_of_range& e) {
9118       {
9119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9120       };
9121     } catch (std::exception& e) {
9122       {
9123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9124       };
9125     } catch (...) {
9126       {
9127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9128       };
9129     }
9130   }
9131   jresult = result;
9132   return jresult;
9133 }
9134
9135
9136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9137   unsigned int jresult ;
9138   Dali::Radian arg1 ;
9139   Dali::Radian arg2 ;
9140   Dali::Radian *argp1 ;
9141   Dali::Radian *argp2 ;
9142   bool result;
9143
9144   argp1 = (Dali::Radian *)jarg1;
9145   if (!argp1) {
9146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9147     return 0;
9148   }
9149   arg1 = *argp1;
9150   argp2 = (Dali::Radian *)jarg2;
9151   if (!argp2) {
9152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9153     return 0;
9154   }
9155   arg2 = *argp2;
9156   {
9157     try {
9158       result = (bool)Dali::operator !=(arg1,arg2);
9159     } catch (std::out_of_range& e) {
9160       {
9161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9162       };
9163     } catch (std::exception& e) {
9164       {
9165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9166       };
9167     } catch (...) {
9168       {
9169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9170       };
9171     }
9172   }
9173   jresult = result;
9174   return jresult;
9175 }
9176
9177
9178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9179   unsigned int jresult ;
9180   Dali::Radian arg1 ;
9181   Dali::Degree arg2 ;
9182   Dali::Radian *argp1 ;
9183   Dali::Degree *argp2 ;
9184   bool result;
9185
9186   argp1 = (Dali::Radian *)jarg1;
9187   if (!argp1) {
9188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9189     return 0;
9190   }
9191   arg1 = *argp1;
9192   argp2 = (Dali::Degree *)jarg2;
9193   if (!argp2) {
9194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9195     return 0;
9196   }
9197   arg2 = *argp2;
9198   {
9199     try {
9200       result = (bool)Dali::operator ==(arg1,arg2);
9201     } catch (std::out_of_range& e) {
9202       {
9203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9204       };
9205     } catch (std::exception& e) {
9206       {
9207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9208       };
9209     } catch (...) {
9210       {
9211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9212       };
9213     }
9214   }
9215   jresult = result;
9216   return jresult;
9217 }
9218
9219
9220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9221   unsigned int jresult ;
9222   Dali::Radian arg1 ;
9223   Dali::Degree arg2 ;
9224   Dali::Radian *argp1 ;
9225   Dali::Degree *argp2 ;
9226   bool result;
9227
9228   argp1 = (Dali::Radian *)jarg1;
9229   if (!argp1) {
9230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9231     return 0;
9232   }
9233   arg1 = *argp1;
9234   argp2 = (Dali::Degree *)jarg2;
9235   if (!argp2) {
9236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9237     return 0;
9238   }
9239   arg2 = *argp2;
9240   {
9241     try {
9242       result = (bool)Dali::operator !=(arg1,arg2);
9243     } catch (std::out_of_range& e) {
9244       {
9245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9246       };
9247     } catch (std::exception& e) {
9248       {
9249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9250       };
9251     } catch (...) {
9252       {
9253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9254       };
9255     }
9256   }
9257   jresult = result;
9258   return jresult;
9259 }
9260
9261
9262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9263   unsigned int jresult ;
9264   Dali::Degree arg1 ;
9265   Dali::Radian arg2 ;
9266   Dali::Degree *argp1 ;
9267   Dali::Radian *argp2 ;
9268   bool result;
9269
9270   argp1 = (Dali::Degree *)jarg1;
9271   if (!argp1) {
9272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9273     return 0;
9274   }
9275   arg1 = *argp1;
9276   argp2 = (Dali::Radian *)jarg2;
9277   if (!argp2) {
9278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9279     return 0;
9280   }
9281   arg2 = *argp2;
9282   {
9283     try {
9284       result = (bool)Dali::operator ==(arg1,arg2);
9285     } catch (std::out_of_range& e) {
9286       {
9287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9288       };
9289     } catch (std::exception& e) {
9290       {
9291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9292       };
9293     } catch (...) {
9294       {
9295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9296       };
9297     }
9298   }
9299   jresult = result;
9300   return jresult;
9301 }
9302
9303
9304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9305   unsigned int jresult ;
9306   Dali::Degree arg1 ;
9307   Dali::Radian arg2 ;
9308   Dali::Degree *argp1 ;
9309   Dali::Radian *argp2 ;
9310   bool result;
9311
9312   argp1 = (Dali::Degree *)jarg1;
9313   if (!argp1) {
9314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9315     return 0;
9316   }
9317   arg1 = *argp1;
9318   argp2 = (Dali::Radian *)jarg2;
9319   if (!argp2) {
9320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9321     return 0;
9322   }
9323   arg2 = *argp2;
9324   {
9325     try {
9326       result = (bool)Dali::operator !=(arg1,arg2);
9327     } catch (std::out_of_range& e) {
9328       {
9329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9330       };
9331     } catch (std::exception& e) {
9332       {
9333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9334       };
9335     } catch (...) {
9336       {
9337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9338       };
9339     }
9340   }
9341   jresult = result;
9342   return jresult;
9343 }
9344
9345
9346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9347   unsigned int jresult ;
9348   Dali::Radian arg1 ;
9349   Dali::Radian arg2 ;
9350   Dali::Radian *argp1 ;
9351   Dali::Radian *argp2 ;
9352   bool result;
9353
9354   argp1 = (Dali::Radian *)jarg1;
9355   if (!argp1) {
9356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9357     return 0;
9358   }
9359   arg1 = *argp1;
9360   argp2 = (Dali::Radian *)jarg2;
9361   if (!argp2) {
9362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9363     return 0;
9364   }
9365   arg2 = *argp2;
9366   {
9367     try {
9368       result = (bool)Dali::operator >(arg1,arg2);
9369     } catch (std::out_of_range& e) {
9370       {
9371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (std::exception& e) {
9374       {
9375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (...) {
9378       {
9379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9380       };
9381     }
9382   }
9383   jresult = result;
9384   return jresult;
9385 }
9386
9387
9388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9389   unsigned int jresult ;
9390   Dali::Radian arg1 ;
9391   Dali::Degree arg2 ;
9392   Dali::Radian *argp1 ;
9393   Dali::Degree *argp2 ;
9394   bool result;
9395
9396   argp1 = (Dali::Radian *)jarg1;
9397   if (!argp1) {
9398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9399     return 0;
9400   }
9401   arg1 = *argp1;
9402   argp2 = (Dali::Degree *)jarg2;
9403   if (!argp2) {
9404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9405     return 0;
9406   }
9407   arg2 = *argp2;
9408   {
9409     try {
9410       result = (bool)Dali::operator >(arg1,arg2);
9411     } catch (std::out_of_range& e) {
9412       {
9413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9414       };
9415     } catch (std::exception& e) {
9416       {
9417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9418       };
9419     } catch (...) {
9420       {
9421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9422       };
9423     }
9424   }
9425   jresult = result;
9426   return jresult;
9427 }
9428
9429
9430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9431   unsigned int jresult ;
9432   Dali::Degree arg1 ;
9433   Dali::Radian arg2 ;
9434   Dali::Degree *argp1 ;
9435   Dali::Radian *argp2 ;
9436   bool result;
9437
9438   argp1 = (Dali::Degree *)jarg1;
9439   if (!argp1) {
9440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9441     return 0;
9442   }
9443   arg1 = *argp1;
9444   argp2 = (Dali::Radian *)jarg2;
9445   if (!argp2) {
9446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9447     return 0;
9448   }
9449   arg2 = *argp2;
9450   {
9451     try {
9452       result = (bool)Dali::operator >(arg1,arg2);
9453     } catch (std::out_of_range& e) {
9454       {
9455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9456       };
9457     } catch (std::exception& e) {
9458       {
9459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9460       };
9461     } catch (...) {
9462       {
9463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9464       };
9465     }
9466   }
9467   jresult = result;
9468   return jresult;
9469 }
9470
9471
9472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9473   unsigned int jresult ;
9474   Dali::Radian arg1 ;
9475   Dali::Radian arg2 ;
9476   Dali::Radian *argp1 ;
9477   Dali::Radian *argp2 ;
9478   bool result;
9479
9480   argp1 = (Dali::Radian *)jarg1;
9481   if (!argp1) {
9482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9483     return 0;
9484   }
9485   arg1 = *argp1;
9486   argp2 = (Dali::Radian *)jarg2;
9487   if (!argp2) {
9488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9489     return 0;
9490   }
9491   arg2 = *argp2;
9492   {
9493     try {
9494       result = (bool)Dali::operator <(arg1,arg2);
9495     } catch (std::out_of_range& e) {
9496       {
9497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9498       };
9499     } catch (std::exception& e) {
9500       {
9501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9502       };
9503     } catch (...) {
9504       {
9505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9506       };
9507     }
9508   }
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9515   unsigned int jresult ;
9516   Dali::Radian arg1 ;
9517   Dali::Degree arg2 ;
9518   Dali::Radian *argp1 ;
9519   Dali::Degree *argp2 ;
9520   bool result;
9521
9522   argp1 = (Dali::Radian *)jarg1;
9523   if (!argp1) {
9524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9525     return 0;
9526   }
9527   arg1 = *argp1;
9528   argp2 = (Dali::Degree *)jarg2;
9529   if (!argp2) {
9530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9531     return 0;
9532   }
9533   arg2 = *argp2;
9534   {
9535     try {
9536       result = (bool)Dali::operator <(arg1,arg2);
9537     } catch (std::out_of_range& e) {
9538       {
9539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9540       };
9541     } catch (std::exception& e) {
9542       {
9543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9544       };
9545     } catch (...) {
9546       {
9547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9548       };
9549     }
9550   }
9551   jresult = result;
9552   return jresult;
9553 }
9554
9555
9556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9557   unsigned int jresult ;
9558   Dali::Degree arg1 ;
9559   Dali::Radian arg2 ;
9560   Dali::Degree *argp1 ;
9561   Dali::Radian *argp2 ;
9562   bool result;
9563
9564   argp1 = (Dali::Degree *)jarg1;
9565   if (!argp1) {
9566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9567     return 0;
9568   }
9569   arg1 = *argp1;
9570   argp2 = (Dali::Radian *)jarg2;
9571   if (!argp2) {
9572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9573     return 0;
9574   }
9575   arg2 = *argp2;
9576   {
9577     try {
9578       result = (bool)Dali::operator <(arg1,arg2);
9579     } catch (std::out_of_range& e) {
9580       {
9581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (std::exception& e) {
9584       {
9585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (...) {
9588       {
9589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9590       };
9591     }
9592   }
9593   jresult = result;
9594   return jresult;
9595 }
9596
9597
9598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9599   void * jresult ;
9600   Dali::Radian arg1 ;
9601   float arg2 ;
9602   Dali::Radian *argp1 ;
9603   Dali::Radian 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   arg2 = (float)jarg2;
9612   {
9613     try {
9614       result = Dali::operator *(arg1,arg2);
9615     } catch (std::out_of_range& e) {
9616       {
9617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9618       };
9619     } catch (std::exception& e) {
9620       {
9621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (...) {
9624       {
9625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9626       };
9627     }
9628   }
9629   jresult = new Dali::Radian((const Dali::Radian &)result);
9630   return jresult;
9631 }
9632
9633
9634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9635   void * jresult ;
9636   Dali::Radian arg1 ;
9637   Dali::Radian *argp1 ;
9638   Dali::Radian result;
9639
9640   argp1 = (Dali::Radian *)jarg1;
9641   if (!argp1) {
9642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9643     return 0;
9644   }
9645   arg1 = *argp1;
9646   {
9647     try {
9648       result = Dali::operator -(arg1);
9649     } catch (std::out_of_range& e) {
9650       {
9651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9652       };
9653     } catch (std::exception& e) {
9654       {
9655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9656       };
9657     } catch (...) {
9658       {
9659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9660       };
9661     }
9662   }
9663   jresult = new Dali::Radian((const Dali::Radian &)result);
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9669   void * jresult ;
9670   Dali::Radian arg1 ;
9671   float arg2 ;
9672   float arg3 ;
9673   Dali::Radian *argp1 ;
9674   Dali::Radian result;
9675
9676   argp1 = (Dali::Radian *)jarg1;
9677   if (!argp1) {
9678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9679     return 0;
9680   }
9681   arg1 = *argp1;
9682   arg2 = (float)jarg2;
9683   arg3 = (float)jarg3;
9684   {
9685     try {
9686       result = Dali::Clamp(arg1,arg2,arg3);
9687     } catch (std::out_of_range& e) {
9688       {
9689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9690       };
9691     } catch (std::exception& e) {
9692       {
9693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9694       };
9695     } catch (...) {
9696       {
9697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9698       };
9699     }
9700   }
9701   jresult = new Dali::Radian((const Dali::Radian &)result);
9702   return jresult;
9703 }
9704
9705
9706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9707   void * jresult ;
9708   Dali::Quaternion *result = 0 ;
9709
9710   {
9711     try {
9712       result = (Dali::Quaternion *)new Dali::Quaternion();
9713     } catch (std::out_of_range& e) {
9714       {
9715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9716       };
9717     } catch (std::exception& e) {
9718       {
9719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9720       };
9721     } catch (...) {
9722       {
9723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9724       };
9725     }
9726   }
9727   jresult = (void *)result;
9728   return jresult;
9729 }
9730
9731
9732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9733   void * jresult ;
9734   Dali::Radian arg1 ;
9735   Dali::Vector3 *arg2 = 0 ;
9736   Dali::Radian *argp1 ;
9737   Dali::Quaternion *result = 0 ;
9738
9739   argp1 = (Dali::Radian *)jarg1;
9740   if (!argp1) {
9741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9742     return 0;
9743   }
9744   arg1 = *argp1;
9745   arg2 = (Dali::Vector3 *)jarg2;
9746   if (!arg2) {
9747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9748     return 0;
9749   }
9750   {
9751     try {
9752       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9753     } catch (std::out_of_range& e) {
9754       {
9755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9756       };
9757     } catch (std::exception& e) {
9758       {
9759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9760       };
9761     } catch (...) {
9762       {
9763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9764       };
9765     }
9766   }
9767   jresult = (void *)result;
9768   return jresult;
9769 }
9770
9771
9772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9773   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9774
9775   arg1 = (Dali::Quaternion *)jarg1;
9776   {
9777     try {
9778       delete arg1;
9779     } catch (std::out_of_range& e) {
9780       {
9781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9782       };
9783     } catch (std::exception& e) {
9784       {
9785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9786       };
9787     } catch (...) {
9788       {
9789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9790       };
9791     }
9792   }
9793 }
9794
9795
9796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9797   void * jresult ;
9798   Dali::Quaternion *result = 0 ;
9799
9800   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9801   jresult = (void *)result;
9802   return jresult;
9803 }
9804
9805
9806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9807   unsigned int jresult ;
9808   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9809   bool result;
9810
9811   arg1 = (Dali::Quaternion *)jarg1;
9812   {
9813     try {
9814       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9815     } catch (std::out_of_range& e) {
9816       {
9817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9818       };
9819     } catch (std::exception& e) {
9820       {
9821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9822       };
9823     } catch (...) {
9824       {
9825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9826       };
9827     }
9828   }
9829   jresult = result;
9830   return jresult;
9831 }
9832
9833
9834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9835   unsigned int jresult ;
9836   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9837   Dali::Vector3 *arg2 = 0 ;
9838   Dali::Radian *arg3 = 0 ;
9839   bool result;
9840
9841   arg1 = (Dali::Quaternion *)jarg1;
9842   arg2 = (Dali::Vector3 *)jarg2;
9843   if (!arg2) {
9844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9845     return 0;
9846   }
9847   arg3 = (Dali::Radian *)jarg3;
9848   if (!arg3) {
9849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9850     return 0;
9851   }
9852   {
9853     try {
9854       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9855     } catch (std::out_of_range& e) {
9856       {
9857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9858       };
9859     } catch (std::exception& e) {
9860       {
9861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9862       };
9863     } catch (...) {
9864       {
9865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9866       };
9867     }
9868   }
9869   jresult = result;
9870   return jresult;
9871 }
9872
9873
9874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9875   void * jresult ;
9876   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9877   Dali::Quaternion *arg2 = 0 ;
9878   Dali::Quaternion result;
9879
9880   arg1 = (Dali::Quaternion *)jarg1;
9881   arg2 = (Dali::Quaternion *)jarg2;
9882   if (!arg2) {
9883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9884     return 0;
9885   }
9886   {
9887     try {
9888       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9889     } catch (std::out_of_range& e) {
9890       {
9891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9892       };
9893     } catch (std::exception& e) {
9894       {
9895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9896       };
9897     } catch (...) {
9898       {
9899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9900       };
9901     }
9902   }
9903   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9904   return jresult;
9905 }
9906
9907
9908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9909   void * jresult ;
9910   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9911   Dali::Quaternion *arg2 = 0 ;
9912   Dali::Quaternion result;
9913
9914   arg1 = (Dali::Quaternion *)jarg1;
9915   arg2 = (Dali::Quaternion *)jarg2;
9916   if (!arg2) {
9917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9918     return 0;
9919   }
9920   {
9921     try {
9922       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9923     } catch (std::out_of_range& e) {
9924       {
9925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9926       };
9927     } catch (std::exception& e) {
9928       {
9929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9930       };
9931     } catch (...) {
9932       {
9933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9934       };
9935     }
9936   }
9937   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9938   return jresult;
9939 }
9940
9941
9942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9943   void * jresult ;
9944   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9945   Dali::Quaternion *arg2 = 0 ;
9946   Dali::Quaternion result;
9947
9948   arg1 = (Dali::Quaternion *)jarg1;
9949   arg2 = (Dali::Quaternion *)jarg2;
9950   if (!arg2) {
9951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9952     return 0;
9953   }
9954   {
9955     try {
9956       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9957     } catch (std::out_of_range& e) {
9958       {
9959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (std::exception& e) {
9962       {
9963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9972   return jresult;
9973 }
9974
9975
9976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9977   void * jresult ;
9978   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9979   Dali::Vector3 *arg2 = 0 ;
9980   Dali::Vector3 result;
9981
9982   arg1 = (Dali::Quaternion *)jarg1;
9983   arg2 = (Dali::Vector3 *)jarg2;
9984   if (!arg2) {
9985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9986     return 0;
9987   }
9988   {
9989     try {
9990       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9991     } catch (std::out_of_range& e) {
9992       {
9993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9994       };
9995     } catch (std::exception& e) {
9996       {
9997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9998       };
9999     } catch (...) {
10000       {
10001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10002       };
10003     }
10004   }
10005   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10011   void * jresult ;
10012   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10013   Dali::Quaternion *arg2 = 0 ;
10014   Dali::Quaternion result;
10015
10016   arg1 = (Dali::Quaternion *)jarg1;
10017   arg2 = (Dali::Quaternion *)jarg2;
10018   if (!arg2) {
10019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10020     return 0;
10021   }
10022   {
10023     try {
10024       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10025     } catch (std::out_of_range& e) {
10026       {
10027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (std::exception& e) {
10030       {
10031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10032       };
10033     } catch (...) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10036       };
10037     }
10038   }
10039   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10040   return jresult;
10041 }
10042
10043
10044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10045   void * jresult ;
10046   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10047   float arg2 ;
10048   Dali::Quaternion result;
10049
10050   arg1 = (Dali::Quaternion *)jarg1;
10051   arg2 = (float)jarg2;
10052   {
10053     try {
10054       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10055     } catch (std::out_of_range& e) {
10056       {
10057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10058       };
10059     } catch (std::exception& e) {
10060       {
10061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10062       };
10063     } catch (...) {
10064       {
10065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10066       };
10067     }
10068   }
10069   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10070   return jresult;
10071 }
10072
10073
10074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10075   void * jresult ;
10076   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10077   float arg2 ;
10078   Dali::Quaternion result;
10079
10080   arg1 = (Dali::Quaternion *)jarg1;
10081   arg2 = (float)jarg2;
10082   {
10083     try {
10084       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10085     } catch (std::out_of_range& e) {
10086       {
10087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (std::exception& e) {
10090       {
10091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (...) {
10094       {
10095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10096       };
10097     }
10098   }
10099   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10100   return jresult;
10101 }
10102
10103
10104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10105   void * jresult ;
10106   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10107   Dali::Quaternion result;
10108
10109   arg1 = (Dali::Quaternion *)jarg1;
10110   {
10111     try {
10112       result = ((Dali::Quaternion const *)arg1)->operator -();
10113     } catch (std::out_of_range& e) {
10114       {
10115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10116       };
10117     } catch (std::exception& e) {
10118       {
10119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10120       };
10121     } catch (...) {
10122       {
10123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10124       };
10125     }
10126   }
10127   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10128   return jresult;
10129 }
10130
10131
10132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10133   void * jresult ;
10134   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10135   Dali::Quaternion *arg2 = 0 ;
10136   Dali::Quaternion *result = 0 ;
10137
10138   arg1 = (Dali::Quaternion *)jarg1;
10139   arg2 = (Dali::Quaternion *)jarg2;
10140   if (!arg2) {
10141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10142     return 0;
10143   }
10144   {
10145     try {
10146       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10147     } catch (std::out_of_range& e) {
10148       {
10149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10150       };
10151     } catch (std::exception& e) {
10152       {
10153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10154       };
10155     } catch (...) {
10156       {
10157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10158       };
10159     }
10160   }
10161   jresult = (void *)result;
10162   return jresult;
10163 }
10164
10165
10166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10167   void * jresult ;
10168   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10169   Dali::Quaternion *arg2 = 0 ;
10170   Dali::Quaternion *result = 0 ;
10171
10172   arg1 = (Dali::Quaternion *)jarg1;
10173   arg2 = (Dali::Quaternion *)jarg2;
10174   if (!arg2) {
10175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10176     return 0;
10177   }
10178   {
10179     try {
10180       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10181     } catch (std::out_of_range& e) {
10182       {
10183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10184       };
10185     } catch (std::exception& e) {
10186       {
10187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10188       };
10189     } catch (...) {
10190       {
10191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10192       };
10193     }
10194   }
10195   jresult = (void *)result;
10196   return jresult;
10197 }
10198
10199
10200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10201   void * jresult ;
10202   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10203   Dali::Quaternion *arg2 = 0 ;
10204   Dali::Quaternion *result = 0 ;
10205
10206   arg1 = (Dali::Quaternion *)jarg1;
10207   arg2 = (Dali::Quaternion *)jarg2;
10208   if (!arg2) {
10209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10210     return 0;
10211   }
10212   {
10213     try {
10214       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10215     } catch (std::out_of_range& e) {
10216       {
10217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10218       };
10219     } catch (std::exception& e) {
10220       {
10221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10222       };
10223     } catch (...) {
10224       {
10225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10226       };
10227     }
10228   }
10229   jresult = (void *)result;
10230   return jresult;
10231 }
10232
10233
10234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10235   void * jresult ;
10236   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10237   float arg2 ;
10238   Dali::Quaternion *result = 0 ;
10239
10240   arg1 = (Dali::Quaternion *)jarg1;
10241   arg2 = (float)jarg2;
10242   {
10243     try {
10244       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10245     } catch (std::out_of_range& e) {
10246       {
10247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10248       };
10249     } catch (std::exception& e) {
10250       {
10251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10252       };
10253     } catch (...) {
10254       {
10255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10256       };
10257     }
10258   }
10259   jresult = (void *)result;
10260   return jresult;
10261 }
10262
10263
10264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10265   void * jresult ;
10266   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10267   float arg2 ;
10268   Dali::Quaternion *result = 0 ;
10269
10270   arg1 = (Dali::Quaternion *)jarg1;
10271   arg2 = (float)jarg2;
10272   {
10273     try {
10274       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10275     } catch (std::out_of_range& e) {
10276       {
10277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (std::exception& e) {
10280       {
10281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (...) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10286       };
10287     }
10288   }
10289   jresult = (void *)result;
10290   return jresult;
10291 }
10292
10293
10294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10295   unsigned int jresult ;
10296   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10297   Dali::Quaternion *arg2 = 0 ;
10298   bool result;
10299
10300   arg1 = (Dali::Quaternion *)jarg1;
10301   arg2 = (Dali::Quaternion *)jarg2;
10302   if (!arg2) {
10303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10304     return 0;
10305   }
10306   {
10307     try {
10308       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10309     } catch (std::out_of_range& e) {
10310       {
10311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10312       };
10313     } catch (std::exception& e) {
10314       {
10315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10316       };
10317     } catch (...) {
10318       {
10319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10320       };
10321     }
10322   }
10323   jresult = result;
10324   return jresult;
10325 }
10326
10327
10328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10329   unsigned int jresult ;
10330   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10331   Dali::Quaternion *arg2 = 0 ;
10332   bool result;
10333
10334   arg1 = (Dali::Quaternion *)jarg1;
10335   arg2 = (Dali::Quaternion *)jarg2;
10336   if (!arg2) {
10337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10338     return 0;
10339   }
10340   {
10341     try {
10342       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10343     } catch (std::out_of_range& e) {
10344       {
10345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10346       };
10347     } catch (std::exception& e) {
10348       {
10349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10350       };
10351     } catch (...) {
10352       {
10353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10354       };
10355     }
10356   }
10357   jresult = result;
10358   return jresult;
10359 }
10360
10361
10362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10363   float jresult ;
10364   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10365   float result;
10366
10367   arg1 = (Dali::Quaternion *)jarg1;
10368   {
10369     try {
10370       result = (float)((Dali::Quaternion const *)arg1)->Length();
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (...) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10382       };
10383     }
10384   }
10385   jresult = result;
10386   return jresult;
10387 }
10388
10389
10390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10391   float jresult ;
10392   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10393   float result;
10394
10395   arg1 = (Dali::Quaternion *)jarg1;
10396   {
10397     try {
10398       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10399     } catch (std::out_of_range& e) {
10400       {
10401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10402       };
10403     } catch (std::exception& e) {
10404       {
10405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10406       };
10407     } catch (...) {
10408       {
10409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10410       };
10411     }
10412   }
10413   jresult = result;
10414   return jresult;
10415 }
10416
10417
10418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10419   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10420
10421   arg1 = (Dali::Quaternion *)jarg1;
10422   {
10423     try {
10424       (arg1)->Normalize();
10425     } catch (std::out_of_range& e) {
10426       {
10427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10428       };
10429     } catch (std::exception& e) {
10430       {
10431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10432       };
10433     } catch (...) {
10434       {
10435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10436       };
10437     }
10438   }
10439 }
10440
10441
10442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10443   void * jresult ;
10444   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10445   Dali::Quaternion result;
10446
10447   arg1 = (Dali::Quaternion *)jarg1;
10448   {
10449     try {
10450       result = ((Dali::Quaternion const *)arg1)->Normalized();
10451     } catch (std::out_of_range& e) {
10452       {
10453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10454       };
10455     } catch (std::exception& e) {
10456       {
10457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10458       };
10459     } catch (...) {
10460       {
10461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10462       };
10463     }
10464   }
10465   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10466   return jresult;
10467 }
10468
10469
10470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10471   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10472
10473   arg1 = (Dali::Quaternion *)jarg1;
10474   {
10475     try {
10476       (arg1)->Conjugate();
10477     } catch (std::out_of_range& e) {
10478       {
10479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10480       };
10481     } catch (std::exception& e) {
10482       {
10483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10484       };
10485     } catch (...) {
10486       {
10487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10488       };
10489     }
10490   }
10491 }
10492
10493
10494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10495   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10496
10497   arg1 = (Dali::Quaternion *)jarg1;
10498   {
10499     try {
10500       (arg1)->Invert();
10501     } catch (std::out_of_range& e) {
10502       {
10503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10504       };
10505     } catch (std::exception& e) {
10506       {
10507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10508       };
10509     } catch (...) {
10510       {
10511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10512       };
10513     }
10514   }
10515 }
10516
10517
10518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10519   void * jresult ;
10520   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10521   Dali::Quaternion result;
10522
10523   arg1 = (Dali::Quaternion *)jarg1;
10524   {
10525     try {
10526       result = ((Dali::Quaternion const *)arg1)->Log();
10527     } catch (std::out_of_range& e) {
10528       {
10529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10530       };
10531     } catch (std::exception& e) {
10532       {
10533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10534       };
10535     } catch (...) {
10536       {
10537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10538       };
10539     }
10540   }
10541   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10542   return jresult;
10543 }
10544
10545
10546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10547   void * jresult ;
10548   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10549   Dali::Quaternion result;
10550
10551   arg1 = (Dali::Quaternion *)jarg1;
10552   {
10553     try {
10554       result = ((Dali::Quaternion const *)arg1)->Exp();
10555     } catch (std::out_of_range& e) {
10556       {
10557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10558       };
10559     } catch (std::exception& e) {
10560       {
10561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (...) {
10564       {
10565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10566       };
10567     }
10568   }
10569   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10570   return jresult;
10571 }
10572
10573
10574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10575   float jresult ;
10576   Dali::Quaternion *arg1 = 0 ;
10577   Dali::Quaternion *arg2 = 0 ;
10578   float result;
10579
10580   arg1 = (Dali::Quaternion *)jarg1;
10581   if (!arg1) {
10582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10583     return 0;
10584   }
10585   arg2 = (Dali::Quaternion *)jarg2;
10586   if (!arg2) {
10587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10588     return 0;
10589   }
10590   {
10591     try {
10592       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10593     } catch (std::out_of_range& e) {
10594       {
10595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10596       };
10597     } catch (std::exception& e) {
10598       {
10599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10600       };
10601     } catch (...) {
10602       {
10603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10604       };
10605     }
10606   }
10607   jresult = result;
10608   return jresult;
10609 }
10610
10611
10612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10613   void * jresult ;
10614   Dali::Quaternion *arg1 = 0 ;
10615   Dali::Quaternion *arg2 = 0 ;
10616   float arg3 ;
10617   Dali::Quaternion result;
10618
10619   arg1 = (Dali::Quaternion *)jarg1;
10620   if (!arg1) {
10621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10622     return 0;
10623   }
10624   arg2 = (Dali::Quaternion *)jarg2;
10625   if (!arg2) {
10626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10627     return 0;
10628   }
10629   arg3 = (float)jarg3;
10630   {
10631     try {
10632       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10633     } catch (std::out_of_range& e) {
10634       {
10635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10636       };
10637     } catch (std::exception& e) {
10638       {
10639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10640       };
10641     } catch (...) {
10642       {
10643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10644       };
10645     }
10646   }
10647   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10648   return jresult;
10649 }
10650
10651
10652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10653   void * jresult ;
10654   Dali::Quaternion *arg1 = 0 ;
10655   Dali::Quaternion *arg2 = 0 ;
10656   float arg3 ;
10657   Dali::Quaternion result;
10658
10659   arg1 = (Dali::Quaternion *)jarg1;
10660   if (!arg1) {
10661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10662     return 0;
10663   }
10664   arg2 = (Dali::Quaternion *)jarg2;
10665   if (!arg2) {
10666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10667     return 0;
10668   }
10669   arg3 = (float)jarg3;
10670   {
10671     try {
10672       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10673     } catch (std::out_of_range& e) {
10674       {
10675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10676       };
10677     } catch (std::exception& e) {
10678       {
10679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10680       };
10681     } catch (...) {
10682       {
10683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10684       };
10685     }
10686   }
10687   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10688   return jresult;
10689 }
10690
10691
10692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10693   void * jresult ;
10694   Dali::Quaternion *arg1 = 0 ;
10695   Dali::Quaternion *arg2 = 0 ;
10696   float arg3 ;
10697   Dali::Quaternion result;
10698
10699   arg1 = (Dali::Quaternion *)jarg1;
10700   if (!arg1) {
10701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10702     return 0;
10703   }
10704   arg2 = (Dali::Quaternion *)jarg2;
10705   if (!arg2) {
10706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10707     return 0;
10708   }
10709   arg3 = (float)jarg3;
10710   {
10711     try {
10712       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10713     } catch (std::out_of_range& e) {
10714       {
10715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10716       };
10717     } catch (std::exception& e) {
10718       {
10719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10720       };
10721     } catch (...) {
10722       {
10723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10724       };
10725     }
10726   }
10727   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10728   return jresult;
10729 }
10730
10731
10732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10733   void * jresult ;
10734   Dali::Quaternion *arg1 = 0 ;
10735   Dali::Quaternion *arg2 = 0 ;
10736   Dali::Quaternion *arg3 = 0 ;
10737   Dali::Quaternion *arg4 = 0 ;
10738   float arg5 ;
10739   Dali::Quaternion result;
10740
10741   arg1 = (Dali::Quaternion *)jarg1;
10742   if (!arg1) {
10743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10744     return 0;
10745   }
10746   arg2 = (Dali::Quaternion *)jarg2;
10747   if (!arg2) {
10748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10749     return 0;
10750   }
10751   arg3 = (Dali::Quaternion *)jarg3;
10752   if (!arg3) {
10753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10754     return 0;
10755   }
10756   arg4 = (Dali::Quaternion *)jarg4;
10757   if (!arg4) {
10758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10759     return 0;
10760   }
10761   arg5 = (float)jarg5;
10762   {
10763     try {
10764       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10765     } catch (std::out_of_range& e) {
10766       {
10767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10768       };
10769     } catch (std::exception& e) {
10770       {
10771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10772       };
10773     } catch (...) {
10774       {
10775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10776       };
10777     }
10778   }
10779   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10780   return jresult;
10781 }
10782
10783
10784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10785   float jresult ;
10786   Dali::Quaternion *arg1 = 0 ;
10787   Dali::Quaternion *arg2 = 0 ;
10788   float result;
10789
10790   arg1 = (Dali::Quaternion *)jarg1;
10791   if (!arg1) {
10792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10793     return 0;
10794   }
10795   arg2 = (Dali::Quaternion *)jarg2;
10796   if (!arg2) {
10797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10798     return 0;
10799   }
10800   {
10801     try {
10802       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10803     } catch (std::out_of_range& e) {
10804       {
10805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10806       };
10807     } catch (std::exception& e) {
10808       {
10809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10810       };
10811     } catch (...) {
10812       {
10813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10814       };
10815     }
10816   }
10817   jresult = result;
10818   return jresult;
10819 }
10820
10821
10822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10823   void * jresult ;
10824   Dali::Matrix *result = 0 ;
10825
10826   {
10827     try {
10828       result = (Dali::Matrix *)new Dali::Matrix();
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (...) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10840       };
10841     }
10842   }
10843   jresult = (void *)result;
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10849   void * jresult ;
10850   bool arg1 ;
10851   Dali::Matrix *result = 0 ;
10852
10853   arg1 = jarg1 ? true : false;
10854   {
10855     try {
10856       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10857     } catch (std::out_of_range& e) {
10858       {
10859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10860       };
10861     } catch (std::exception& e) {
10862       {
10863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10864       };
10865     } catch (...) {
10866       {
10867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10868       };
10869     }
10870   }
10871   jresult = (void *)result;
10872   return jresult;
10873 }
10874
10875
10876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10877   void * jresult ;
10878   float *arg1 = (float *) 0 ;
10879   Dali::Matrix *result = 0 ;
10880
10881   arg1 = jarg1;
10882   {
10883     try {
10884       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10885     } catch (std::out_of_range& e) {
10886       {
10887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10888       };
10889     } catch (std::exception& e) {
10890       {
10891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10892       };
10893     } catch (...) {
10894       {
10895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10896       };
10897     }
10898   }
10899   jresult = (void *)result;
10900
10901
10902   return jresult;
10903 }
10904
10905
10906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10907   void * jresult ;
10908   Dali::Quaternion *arg1 = 0 ;
10909   Dali::Matrix *result = 0 ;
10910
10911   arg1 = (Dali::Quaternion *)jarg1;
10912   if (!arg1) {
10913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10914     return 0;
10915   }
10916   {
10917     try {
10918       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10919     } catch (std::out_of_range& e) {
10920       {
10921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10922       };
10923     } catch (std::exception& e) {
10924       {
10925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10926       };
10927     } catch (...) {
10928       {
10929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10930       };
10931     }
10932   }
10933   jresult = (void *)result;
10934   return jresult;
10935 }
10936
10937
10938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10939   void * jresult ;
10940   Dali::Matrix *arg1 = 0 ;
10941   Dali::Matrix *result = 0 ;
10942
10943   arg1 = (Dali::Matrix *)jarg1;
10944   if (!arg1) {
10945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10946     return 0;
10947   }
10948   {
10949     try {
10950       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10951     } catch (std::out_of_range& e) {
10952       {
10953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10954       };
10955     } catch (std::exception& e) {
10956       {
10957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10958       };
10959     } catch (...) {
10960       {
10961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10962       };
10963     }
10964   }
10965   jresult = (void *)result;
10966   return jresult;
10967 }
10968
10969
10970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10971   void * jresult ;
10972   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10973   Dali::Matrix *arg2 = 0 ;
10974   Dali::Matrix *result = 0 ;
10975
10976   arg1 = (Dali::Matrix *)jarg1;
10977   arg2 = (Dali::Matrix *)jarg2;
10978   if (!arg2) {
10979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10980     return 0;
10981   }
10982   {
10983     try {
10984       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10985     } catch (std::out_of_range& e) {
10986       {
10987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10988       };
10989     } catch (std::exception& e) {
10990       {
10991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10992       };
10993     } catch (...) {
10994       {
10995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10996       };
10997     }
10998   }
10999   jresult = (void *)result;
11000   return jresult;
11001 }
11002
11003
11004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11005   void * jresult ;
11006   Dali::Matrix *result = 0 ;
11007
11008   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11009   jresult = (void *)result;
11010   return jresult;
11011 }
11012
11013
11014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11015   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11016
11017   arg1 = (Dali::Matrix *)jarg1;
11018   {
11019     try {
11020       (arg1)->SetIdentity();
11021     } catch (std::out_of_range& e) {
11022       {
11023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11024       };
11025     } catch (std::exception& e) {
11026       {
11027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11028       };
11029     } catch (...) {
11030       {
11031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11032       };
11033     }
11034   }
11035 }
11036
11037
11038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11039   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11040   Dali::Vector3 *arg2 = 0 ;
11041
11042   arg1 = (Dali::Matrix *)jarg1;
11043   arg2 = (Dali::Vector3 *)jarg2;
11044   if (!arg2) {
11045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11046     return ;
11047   }
11048   {
11049     try {
11050       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11051     } catch (std::out_of_range& e) {
11052       {
11053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11054       };
11055     } catch (std::exception& e) {
11056       {
11057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11058       };
11059     } catch (...) {
11060       {
11061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11062       };
11063     }
11064   }
11065 }
11066
11067
11068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11069   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11070   Dali::Matrix *arg2 = 0 ;
11071
11072   arg1 = (Dali::Matrix *)jarg1;
11073   arg2 = (Dali::Matrix *)jarg2;
11074   if (!arg2) {
11075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11076     return ;
11077   }
11078   {
11079     try {
11080       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11081     } catch (std::out_of_range& e) {
11082       {
11083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11084       };
11085     } catch (std::exception& e) {
11086       {
11087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11088       };
11089     } catch (...) {
11090       {
11091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11092       };
11093     }
11094   }
11095 }
11096
11097
11098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11099   unsigned int jresult ;
11100   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11101   bool result;
11102
11103   arg1 = (Dali::Matrix *)jarg1;
11104   {
11105     try {
11106       result = (bool)(arg1)->Invert();
11107     } catch (std::out_of_range& e) {
11108       {
11109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11110       };
11111     } catch (std::exception& e) {
11112       {
11113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11114       };
11115     } catch (...) {
11116       {
11117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11118       };
11119     }
11120   }
11121   jresult = result;
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11127   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11128
11129   arg1 = (Dali::Matrix *)jarg1;
11130   {
11131     try {
11132       (arg1)->Transpose();
11133     } catch (std::out_of_range& e) {
11134       {
11135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11136       };
11137     } catch (std::exception& e) {
11138       {
11139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11140       };
11141     } catch (...) {
11142       {
11143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11144       };
11145     }
11146   }
11147 }
11148
11149
11150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11151   void * jresult ;
11152   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11153   Dali::Vector3 result;
11154
11155   arg1 = (Dali::Matrix *)jarg1;
11156   {
11157     try {
11158       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11159     } catch (std::out_of_range& e) {
11160       {
11161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11162       };
11163     } catch (std::exception& e) {
11164       {
11165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11166       };
11167     } catch (...) {
11168       {
11169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11170       };
11171     }
11172   }
11173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11174   return jresult;
11175 }
11176
11177
11178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11179   void * jresult ;
11180   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11181   Dali::Vector3 result;
11182
11183   arg1 = (Dali::Matrix *)jarg1;
11184   {
11185     try {
11186       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11187     } catch (std::out_of_range& e) {
11188       {
11189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (std::exception& e) {
11192       {
11193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11194       };
11195     } catch (...) {
11196       {
11197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11198       };
11199     }
11200   }
11201   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11207   void * jresult ;
11208   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11209   Dali::Vector3 result;
11210
11211   arg1 = (Dali::Matrix *)jarg1;
11212   {
11213     try {
11214       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11215     } catch (std::out_of_range& e) {
11216       {
11217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11218       };
11219     } catch (std::exception& e) {
11220       {
11221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (...) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11226       };
11227     }
11228   }
11229   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11230   return jresult;
11231 }
11232
11233
11234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11235   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11236   Dali::Vector3 *arg2 = 0 ;
11237
11238   arg1 = (Dali::Matrix *)jarg1;
11239   arg2 = (Dali::Vector3 *)jarg2;
11240   if (!arg2) {
11241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11242     return ;
11243   }
11244   {
11245     try {
11246       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11247     } catch (std::out_of_range& e) {
11248       {
11249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11250       };
11251     } catch (std::exception& e) {
11252       {
11253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11254       };
11255     } catch (...) {
11256       {
11257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11258       };
11259     }
11260   }
11261 }
11262
11263
11264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11265   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11266   Dali::Vector3 *arg2 = 0 ;
11267
11268   arg1 = (Dali::Matrix *)jarg1;
11269   arg2 = (Dali::Vector3 *)jarg2;
11270   if (!arg2) {
11271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11272     return ;
11273   }
11274   {
11275     try {
11276       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11277     } catch (std::out_of_range& e) {
11278       {
11279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11280       };
11281     } catch (std::exception& e) {
11282       {
11283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11284       };
11285     } catch (...) {
11286       {
11287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11288       };
11289     }
11290   }
11291 }
11292
11293
11294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11295   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11296   Dali::Vector3 *arg2 = 0 ;
11297
11298   arg1 = (Dali::Matrix *)jarg1;
11299   arg2 = (Dali::Vector3 *)jarg2;
11300   if (!arg2) {
11301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11302     return ;
11303   }
11304   {
11305     try {
11306       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11307     } catch (std::out_of_range& e) {
11308       {
11309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11310       };
11311     } catch (std::exception& e) {
11312       {
11313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11314       };
11315     } catch (...) {
11316       {
11317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11318       };
11319     }
11320   }
11321 }
11322
11323
11324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11325   void * jresult ;
11326   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11327   Dali::Vector4 *result = 0 ;
11328
11329   arg1 = (Dali::Matrix *)jarg1;
11330   {
11331     try {
11332       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11333     } catch (std::out_of_range& e) {
11334       {
11335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11336       };
11337     } catch (std::exception& e) {
11338       {
11339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11340       };
11341     } catch (...) {
11342       {
11343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11344       };
11345     }
11346   }
11347   jresult = (void *)result;
11348   return jresult;
11349 }
11350
11351
11352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11353   void * jresult ;
11354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11355   Dali::Vector3 *result = 0 ;
11356
11357   arg1 = (Dali::Matrix *)jarg1;
11358   {
11359     try {
11360       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11361     } catch (std::out_of_range& e) {
11362       {
11363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (std::exception& e) {
11366       {
11367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11368       };
11369     } catch (...) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11372       };
11373     }
11374   }
11375   jresult = (void *)result;
11376   return jresult;
11377 }
11378
11379
11380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11381   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11382   Dali::Vector4 *arg2 = 0 ;
11383
11384   arg1 = (Dali::Matrix *)jarg1;
11385   arg2 = (Dali::Vector4 *)jarg2;
11386   if (!arg2) {
11387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11388     return ;
11389   }
11390   {
11391     try {
11392       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11393     } catch (std::out_of_range& e) {
11394       {
11395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11396       };
11397     } catch (std::exception& e) {
11398       {
11399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11400       };
11401     } catch (...) {
11402       {
11403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11404       };
11405     }
11406   }
11407 }
11408
11409
11410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11411   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11412   Dali::Vector3 *arg2 = 0 ;
11413
11414   arg1 = (Dali::Matrix *)jarg1;
11415   arg2 = (Dali::Vector3 *)jarg2;
11416   if (!arg2) {
11417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11418     return ;
11419   }
11420   {
11421     try {
11422       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11423     } catch (std::out_of_range& e) {
11424       {
11425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11426       };
11427     } catch (std::exception& e) {
11428       {
11429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11430       };
11431     } catch (...) {
11432       {
11433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11434       };
11435     }
11436   }
11437 }
11438
11439
11440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11441   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11442
11443   arg1 = (Dali::Matrix *)jarg1;
11444   {
11445     try {
11446       (arg1)->OrthoNormalize();
11447     } catch (std::out_of_range& e) {
11448       {
11449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11450       };
11451     } catch (std::exception& e) {
11452       {
11453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11454       };
11455     } catch (...) {
11456       {
11457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11458       };
11459     }
11460   }
11461 }
11462
11463
11464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11465   void * jresult ;
11466   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11467   float *result = 0 ;
11468
11469   arg1 = (Dali::Matrix *)jarg1;
11470   {
11471     try {
11472       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11473     } catch (std::out_of_range& e) {
11474       {
11475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11476       };
11477     } catch (std::exception& e) {
11478       {
11479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11480       };
11481     } catch (...) {
11482       {
11483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11484       };
11485     }
11486   }
11487   jresult = (void *)result;
11488   return jresult;
11489 }
11490
11491
11492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11493   Dali::Matrix *arg1 = 0 ;
11494   Dali::Matrix *arg2 = 0 ;
11495   Dali::Matrix *arg3 = 0 ;
11496
11497   arg1 = (Dali::Matrix *)jarg1;
11498   if (!arg1) {
11499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11500     return ;
11501   }
11502   arg2 = (Dali::Matrix *)jarg2;
11503   if (!arg2) {
11504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11505     return ;
11506   }
11507   arg3 = (Dali::Matrix *)jarg3;
11508   if (!arg3) {
11509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11510     return ;
11511   }
11512   {
11513     try {
11514       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11515     } catch (std::out_of_range& e) {
11516       {
11517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11518       };
11519     } catch (std::exception& e) {
11520       {
11521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11522       };
11523     } catch (...) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11526       };
11527     }
11528   }
11529 }
11530
11531
11532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11533   Dali::Matrix *arg1 = 0 ;
11534   Dali::Matrix *arg2 = 0 ;
11535   Dali::Quaternion *arg3 = 0 ;
11536
11537   arg1 = (Dali::Matrix *)jarg1;
11538   if (!arg1) {
11539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11540     return ;
11541   }
11542   arg2 = (Dali::Matrix *)jarg2;
11543   if (!arg2) {
11544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11545     return ;
11546   }
11547   arg3 = (Dali::Quaternion *)jarg3;
11548   if (!arg3) {
11549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11550     return ;
11551   }
11552   {
11553     try {
11554       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11555     } catch (std::out_of_range& e) {
11556       {
11557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11558       };
11559     } catch (std::exception& e) {
11560       {
11561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11562       };
11563     } catch (...) {
11564       {
11565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11566       };
11567     }
11568   }
11569 }
11570
11571
11572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11573   void * jresult ;
11574   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11575   Dali::Vector4 *arg2 = 0 ;
11576   Dali::Vector4 result;
11577
11578   arg1 = (Dali::Matrix *)jarg1;
11579   arg2 = (Dali::Vector4 *)jarg2;
11580   if (!arg2) {
11581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11582     return 0;
11583   }
11584   {
11585     try {
11586       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11587     } catch (std::out_of_range& e) {
11588       {
11589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (std::exception& e) {
11592       {
11593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11594       };
11595     } catch (...) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11598       };
11599     }
11600   }
11601   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11602   return jresult;
11603 }
11604
11605
11606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11607   unsigned int jresult ;
11608   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11609   Dali::Matrix *arg2 = 0 ;
11610   bool result;
11611
11612   arg1 = (Dali::Matrix *)jarg1;
11613   arg2 = (Dali::Matrix *)jarg2;
11614   if (!arg2) {
11615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11616     return 0;
11617   }
11618   {
11619     try {
11620       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11621     } catch (std::out_of_range& e) {
11622       {
11623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11624       };
11625     } catch (std::exception& e) {
11626       {
11627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11628       };
11629     } catch (...) {
11630       {
11631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11632       };
11633     }
11634   }
11635   jresult = result;
11636   return jresult;
11637 }
11638
11639
11640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11641   unsigned int jresult ;
11642   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11643   Dali::Matrix *arg2 = 0 ;
11644   bool result;
11645
11646   arg1 = (Dali::Matrix *)jarg1;
11647   arg2 = (Dali::Matrix *)jarg2;
11648   if (!arg2) {
11649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11650     return 0;
11651   }
11652   {
11653     try {
11654       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11655     } catch (std::out_of_range& e) {
11656       {
11657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11658       };
11659     } catch (std::exception& e) {
11660       {
11661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (...) {
11664       {
11665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11666       };
11667     }
11668   }
11669   jresult = result;
11670   return jresult;
11671 }
11672
11673
11674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11675   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11676   Dali::Vector3 *arg2 = 0 ;
11677   Dali::Quaternion *arg3 = 0 ;
11678   Dali::Vector3 *arg4 = 0 ;
11679
11680   arg1 = (Dali::Matrix *)jarg1;
11681   arg2 = (Dali::Vector3 *)jarg2;
11682   if (!arg2) {
11683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11684     return ;
11685   }
11686   arg3 = (Dali::Quaternion *)jarg3;
11687   if (!arg3) {
11688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11689     return ;
11690   }
11691   arg4 = (Dali::Vector3 *)jarg4;
11692   if (!arg4) {
11693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11694     return ;
11695   }
11696   {
11697     try {
11698       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11699     } catch (std::out_of_range& e) {
11700       {
11701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11702       };
11703     } catch (std::exception& e) {
11704       {
11705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11706       };
11707     } catch (...) {
11708       {
11709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11710       };
11711     }
11712   }
11713 }
11714
11715
11716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11717   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11718   Dali::Vector3 *arg2 = 0 ;
11719   Dali::Quaternion *arg3 = 0 ;
11720   Dali::Vector3 *arg4 = 0 ;
11721
11722   arg1 = (Dali::Matrix *)jarg1;
11723   arg2 = (Dali::Vector3 *)jarg2;
11724   if (!arg2) {
11725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11726     return ;
11727   }
11728   arg3 = (Dali::Quaternion *)jarg3;
11729   if (!arg3) {
11730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11731     return ;
11732   }
11733   arg4 = (Dali::Vector3 *)jarg4;
11734   if (!arg4) {
11735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11736     return ;
11737   }
11738   {
11739     try {
11740       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11741     } catch (std::out_of_range& e) {
11742       {
11743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11744       };
11745     } catch (std::exception& e) {
11746       {
11747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11748       };
11749     } catch (...) {
11750       {
11751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11752       };
11753     }
11754   }
11755 }
11756
11757
11758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11759   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11760   Dali::Vector3 *arg2 = 0 ;
11761   Dali::Vector3 *arg3 = 0 ;
11762   Dali::Vector3 *arg4 = 0 ;
11763   Dali::Vector3 *arg5 = 0 ;
11764
11765   arg1 = (Dali::Matrix *)jarg1;
11766   arg2 = (Dali::Vector3 *)jarg2;
11767   if (!arg2) {
11768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11769     return ;
11770   }
11771   arg3 = (Dali::Vector3 *)jarg3;
11772   if (!arg3) {
11773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11774     return ;
11775   }
11776   arg4 = (Dali::Vector3 *)jarg4;
11777   if (!arg4) {
11778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11779     return ;
11780   }
11781   arg5 = (Dali::Vector3 *)jarg5;
11782   if (!arg5) {
11783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11784     return ;
11785   }
11786   {
11787     try {
11788       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11789     } catch (std::out_of_range& e) {
11790       {
11791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11792       };
11793     } catch (std::exception& e) {
11794       {
11795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11796       };
11797     } catch (...) {
11798       {
11799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11800       };
11801     }
11802   }
11803 }
11804
11805
11806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11807   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11808   Dali::Vector3 *arg2 = 0 ;
11809   Dali::Quaternion *arg3 = 0 ;
11810   Dali::Vector3 *arg4 = 0 ;
11811
11812   arg1 = (Dali::Matrix *)jarg1;
11813   arg2 = (Dali::Vector3 *)jarg2;
11814   if (!arg2) {
11815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11816     return ;
11817   }
11818   arg3 = (Dali::Quaternion *)jarg3;
11819   if (!arg3) {
11820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11821     return ;
11822   }
11823   arg4 = (Dali::Vector3 *)jarg4;
11824   if (!arg4) {
11825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11826     return ;
11827   }
11828   {
11829     try {
11830       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11831     } catch (std::out_of_range& e) {
11832       {
11833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11834       };
11835     } catch (std::exception& e) {
11836       {
11837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11838       };
11839     } catch (...) {
11840       {
11841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11842       };
11843     }
11844   }
11845 }
11846
11847
11848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11849   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11850
11851   arg1 = (Dali::Matrix *)jarg1;
11852   {
11853     try {
11854       delete arg1;
11855     } catch (std::out_of_range& e) {
11856       {
11857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11858       };
11859     } catch (std::exception& e) {
11860       {
11861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11862       };
11863     } catch (...) {
11864       {
11865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11866       };
11867     }
11868   }
11869 }
11870
11871
11872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11873   void * jresult ;
11874   Dali::Matrix3 *result = 0 ;
11875
11876   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11877   jresult = (void *)result;
11878   return jresult;
11879 }
11880
11881
11882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11883   void * jresult ;
11884   Dali::Matrix3 *result = 0 ;
11885
11886   {
11887     try {
11888       result = (Dali::Matrix3 *)new Dali::Matrix3();
11889     } catch (std::out_of_range& e) {
11890       {
11891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11892       };
11893     } catch (std::exception& e) {
11894       {
11895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11896       };
11897     } catch (...) {
11898       {
11899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11900       };
11901     }
11902   }
11903   jresult = (void *)result;
11904   return jresult;
11905 }
11906
11907
11908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11909   void * jresult ;
11910   Dali::Matrix3 *arg1 = 0 ;
11911   Dali::Matrix3 *result = 0 ;
11912
11913   arg1 = (Dali::Matrix3 *)jarg1;
11914   if (!arg1) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11916     return 0;
11917   }
11918   {
11919     try {
11920       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (...) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11932       };
11933     }
11934   }
11935   jresult = (void *)result;
11936   return jresult;
11937 }
11938
11939
11940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11941   void * jresult ;
11942   Dali::Matrix *arg1 = 0 ;
11943   Dali::Matrix3 *result = 0 ;
11944
11945   arg1 = (Dali::Matrix *)jarg1;
11946   if (!arg1) {
11947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11948     return 0;
11949   }
11950   {
11951     try {
11952       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11953     } catch (std::out_of_range& e) {
11954       {
11955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11956       };
11957     } catch (std::exception& e) {
11958       {
11959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11960       };
11961     } catch (...) {
11962       {
11963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11964       };
11965     }
11966   }
11967   jresult = (void *)result;
11968   return jresult;
11969 }
11970
11971
11972 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) {
11973   void * jresult ;
11974   float arg1 ;
11975   float arg2 ;
11976   float arg3 ;
11977   float arg4 ;
11978   float arg5 ;
11979   float arg6 ;
11980   float arg7 ;
11981   float arg8 ;
11982   float arg9 ;
11983   Dali::Matrix3 *result = 0 ;
11984
11985   arg1 = (float)jarg1;
11986   arg2 = (float)jarg2;
11987   arg3 = (float)jarg3;
11988   arg4 = (float)jarg4;
11989   arg5 = (float)jarg5;
11990   arg6 = (float)jarg6;
11991   arg7 = (float)jarg7;
11992   arg8 = (float)jarg8;
11993   arg9 = (float)jarg9;
11994   {
11995     try {
11996       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11997     } catch (std::out_of_range& e) {
11998       {
11999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12000       };
12001     } catch (std::exception& e) {
12002       {
12003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12004       };
12005     } catch (...) {
12006       {
12007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12008       };
12009     }
12010   }
12011   jresult = (void *)result;
12012   return jresult;
12013 }
12014
12015
12016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12017   void * jresult ;
12018   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12019   Dali::Matrix3 *arg2 = 0 ;
12020   Dali::Matrix3 *result = 0 ;
12021
12022   arg1 = (Dali::Matrix3 *)jarg1;
12023   arg2 = (Dali::Matrix3 *)jarg2;
12024   if (!arg2) {
12025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12026     return 0;
12027   }
12028   {
12029     try {
12030       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12031     } catch (std::out_of_range& e) {
12032       {
12033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12034       };
12035     } catch (std::exception& e) {
12036       {
12037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12038       };
12039     } catch (...) {
12040       {
12041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12042       };
12043     }
12044   }
12045   jresult = (void *)result;
12046   return jresult;
12047 }
12048
12049
12050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12051   void * jresult ;
12052   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12053   Dali::Matrix *arg2 = 0 ;
12054   Dali::Matrix3 *result = 0 ;
12055
12056   arg1 = (Dali::Matrix3 *)jarg1;
12057   arg2 = (Dali::Matrix *)jarg2;
12058   if (!arg2) {
12059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12060     return 0;
12061   }
12062   {
12063     try {
12064       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12065     } catch (std::out_of_range& e) {
12066       {
12067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12068       };
12069     } catch (std::exception& e) {
12070       {
12071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12072       };
12073     } catch (...) {
12074       {
12075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12076       };
12077     }
12078   }
12079   jresult = (void *)result;
12080   return jresult;
12081 }
12082
12083
12084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12085   unsigned int jresult ;
12086   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12087   Dali::Matrix3 *arg2 = 0 ;
12088   bool result;
12089
12090   arg1 = (Dali::Matrix3 *)jarg1;
12091   arg2 = (Dali::Matrix3 *)jarg2;
12092   if (!arg2) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12094     return 0;
12095   }
12096   {
12097     try {
12098       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12099     } catch (std::out_of_range& e) {
12100       {
12101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12102       };
12103     } catch (std::exception& e) {
12104       {
12105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12106       };
12107     } catch (...) {
12108       {
12109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12110       };
12111     }
12112   }
12113   jresult = result;
12114   return jresult;
12115 }
12116
12117
12118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12119   unsigned int jresult ;
12120   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12121   Dali::Matrix3 *arg2 = 0 ;
12122   bool result;
12123
12124   arg1 = (Dali::Matrix3 *)jarg1;
12125   arg2 = (Dali::Matrix3 *)jarg2;
12126   if (!arg2) {
12127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12128     return 0;
12129   }
12130   {
12131     try {
12132       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12133     } catch (std::out_of_range& e) {
12134       {
12135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12136       };
12137     } catch (std::exception& e) {
12138       {
12139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12140       };
12141     } catch (...) {
12142       {
12143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12144       };
12145     }
12146   }
12147   jresult = result;
12148   return jresult;
12149 }
12150
12151
12152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12153   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12154
12155   arg1 = (Dali::Matrix3 *)jarg1;
12156   {
12157     try {
12158       delete arg1;
12159     } catch (std::out_of_range& e) {
12160       {
12161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12162       };
12163     } catch (std::exception& e) {
12164       {
12165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12170       };
12171     }
12172   }
12173 }
12174
12175
12176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12177   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12178
12179   arg1 = (Dali::Matrix3 *)jarg1;
12180   {
12181     try {
12182       (arg1)->SetIdentity();
12183     } catch (std::out_of_range& e) {
12184       {
12185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12186       };
12187     } catch (std::exception& e) {
12188       {
12189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12190       };
12191     } catch (...) {
12192       {
12193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12194       };
12195     }
12196   }
12197 }
12198
12199
12200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12201   void * jresult ;
12202   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12203   float *result = 0 ;
12204
12205   arg1 = (Dali::Matrix3 *)jarg1;
12206   {
12207     try {
12208       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12209     } catch (std::out_of_range& e) {
12210       {
12211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12212       };
12213     } catch (std::exception& e) {
12214       {
12215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12216       };
12217     } catch (...) {
12218       {
12219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12220       };
12221     }
12222   }
12223   jresult = (void *)result;
12224   return jresult;
12225 }
12226
12227
12228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12229   unsigned int jresult ;
12230   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12231   bool result;
12232
12233   arg1 = (Dali::Matrix3 *)jarg1;
12234   {
12235     try {
12236       result = (bool)(arg1)->Invert();
12237     } catch (std::out_of_range& e) {
12238       {
12239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12240       };
12241     } catch (std::exception& e) {
12242       {
12243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12244       };
12245     } catch (...) {
12246       {
12247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12248       };
12249     }
12250   }
12251   jresult = result;
12252   return jresult;
12253 }
12254
12255
12256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12257   unsigned int jresult ;
12258   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12259   bool result;
12260
12261   arg1 = (Dali::Matrix3 *)jarg1;
12262   {
12263     try {
12264       result = (bool)(arg1)->Transpose();
12265     } catch (std::out_of_range& e) {
12266       {
12267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12268       };
12269     } catch (std::exception& e) {
12270       {
12271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12272       };
12273     } catch (...) {
12274       {
12275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12276       };
12277     }
12278   }
12279   jresult = result;
12280   return jresult;
12281 }
12282
12283
12284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12285   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12286   float arg2 ;
12287
12288   arg1 = (Dali::Matrix3 *)jarg1;
12289   arg2 = (float)jarg2;
12290   {
12291     try {
12292       (arg1)->Scale(arg2);
12293     } catch (std::out_of_range& e) {
12294       {
12295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12296       };
12297     } catch (std::exception& e) {
12298       {
12299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12300       };
12301     } catch (...) {
12302       {
12303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12304       };
12305     }
12306   }
12307 }
12308
12309
12310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12311   float jresult ;
12312   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12313   float result;
12314
12315   arg1 = (Dali::Matrix3 *)jarg1;
12316   {
12317     try {
12318       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12319     } catch (std::out_of_range& e) {
12320       {
12321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12322       };
12323     } catch (std::exception& e) {
12324       {
12325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (...) {
12328       {
12329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12330       };
12331     }
12332   }
12333   jresult = result;
12334   return jresult;
12335 }
12336
12337
12338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12339   unsigned int jresult ;
12340   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12341   bool result;
12342
12343   arg1 = (Dali::Matrix3 *)jarg1;
12344   {
12345     try {
12346       result = (bool)(arg1)->ScaledInverseTranspose();
12347     } catch (std::out_of_range& e) {
12348       {
12349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12350       };
12351     } catch (std::exception& e) {
12352       {
12353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12354       };
12355     } catch (...) {
12356       {
12357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12358       };
12359     }
12360   }
12361   jresult = result;
12362   return jresult;
12363 }
12364
12365
12366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12367   Dali::Matrix3 *arg1 = 0 ;
12368   Dali::Matrix3 *arg2 = 0 ;
12369   Dali::Matrix3 *arg3 = 0 ;
12370
12371   arg1 = (Dali::Matrix3 *)jarg1;
12372   if (!arg1) {
12373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12374     return ;
12375   }
12376   arg2 = (Dali::Matrix3 *)jarg2;
12377   if (!arg2) {
12378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12379     return ;
12380   }
12381   arg3 = (Dali::Matrix3 *)jarg3;
12382   if (!arg3) {
12383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12384     return ;
12385   }
12386   {
12387     try {
12388       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12389     } catch (std::out_of_range& e) {
12390       {
12391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12392       };
12393     } catch (std::exception& e) {
12394       {
12395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12396       };
12397     } catch (...) {
12398       {
12399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12400       };
12401     }
12402   }
12403 }
12404
12405
12406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12407   float jresult ;
12408   float arg1 ;
12409   float arg2 ;
12410   float result;
12411
12412   arg1 = (float)jarg1;
12413   arg2 = (float)jarg2;
12414   {
12415     try {
12416       result = (float)Dali::Random::Range(arg1,arg2);
12417     } catch (std::out_of_range& e) {
12418       {
12419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12420       };
12421     } catch (std::exception& e) {
12422       {
12423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12424       };
12425     } catch (...) {
12426       {
12427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12428       };
12429     }
12430   }
12431   jresult = result;
12432   return jresult;
12433 }
12434
12435
12436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12437   void * jresult ;
12438   Dali::Vector4 result;
12439
12440   {
12441     try {
12442       result = Dali::Random::Axis();
12443     } catch (std::out_of_range& e) {
12444       {
12445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12446       };
12447     } catch (std::exception& e) {
12448       {
12449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12450       };
12451     } catch (...) {
12452       {
12453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12454       };
12455     }
12456   }
12457   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12458   return jresult;
12459 }
12460
12461
12462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12463   void * jresult ;
12464   Dali::AngleAxis *result = 0 ;
12465
12466   {
12467     try {
12468       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12469     } catch (std::out_of_range& e) {
12470       {
12471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12472       };
12473     } catch (std::exception& e) {
12474       {
12475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12480       };
12481     }
12482   }
12483   jresult = (void *)result;
12484   return jresult;
12485 }
12486
12487
12488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12489   void * jresult ;
12490   Dali::Radian arg1 ;
12491   Dali::Vector3 *arg2 = 0 ;
12492   Dali::Radian *argp1 ;
12493   Dali::AngleAxis *result = 0 ;
12494
12495   argp1 = (Dali::Radian *)jarg1;
12496   if (!argp1) {
12497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12498     return 0;
12499   }
12500   arg1 = *argp1;
12501   arg2 = (Dali::Vector3 *)jarg2;
12502   if (!arg2) {
12503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12504     return 0;
12505   }
12506   {
12507     try {
12508       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12509     } catch (std::out_of_range& e) {
12510       {
12511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12512       };
12513     } catch (std::exception& e) {
12514       {
12515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12516       };
12517     } catch (...) {
12518       {
12519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12520       };
12521     }
12522   }
12523   jresult = (void *)result;
12524   return jresult;
12525 }
12526
12527
12528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12529   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12530   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12531
12532   arg1 = (Dali::AngleAxis *)jarg1;
12533   arg2 = (Dali::Radian *)jarg2;
12534   if (arg1) (arg1)->angle = *arg2;
12535 }
12536
12537
12538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12539   void * jresult ;
12540   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12541   Dali::Radian *result = 0 ;
12542
12543   arg1 = (Dali::AngleAxis *)jarg1;
12544   result = (Dali::Radian *)& ((arg1)->angle);
12545   jresult = (void *)result;
12546   return jresult;
12547 }
12548
12549
12550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12551   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12552   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12553
12554   arg1 = (Dali::AngleAxis *)jarg1;
12555   arg2 = (Dali::Vector3 *)jarg2;
12556   if (arg1) (arg1)->axis = *arg2;
12557 }
12558
12559
12560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12561   void * jresult ;
12562   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12563   Dali::Vector3 *result = 0 ;
12564
12565   arg1 = (Dali::AngleAxis *)jarg1;
12566   result = (Dali::Vector3 *)& ((arg1)->axis);
12567   jresult = (void *)result;
12568   return jresult;
12569 }
12570
12571
12572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12573   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12574
12575   arg1 = (Dali::AngleAxis *)jarg1;
12576   {
12577     try {
12578       delete arg1;
12579     } catch (std::out_of_range& e) {
12580       {
12581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12582       };
12583     } catch (std::exception& e) {
12584       {
12585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12586       };
12587     } catch (...) {
12588       {
12589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12590       };
12591     }
12592   }
12593 }
12594
12595
12596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12597   unsigned int jresult ;
12598   Dali::AngleAxis *arg1 = 0 ;
12599   Dali::AngleAxis *arg2 = 0 ;
12600   bool result;
12601
12602   arg1 = (Dali::AngleAxis *)jarg1;
12603   if (!arg1) {
12604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12605     return 0;
12606   }
12607   arg2 = (Dali::AngleAxis *)jarg2;
12608   if (!arg2) {
12609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12610     return 0;
12611   }
12612   {
12613     try {
12614       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12615     } catch (std::out_of_range& e) {
12616       {
12617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12618       };
12619     } catch (std::exception& e) {
12620       {
12621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12622       };
12623     } catch (...) {
12624       {
12625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12626       };
12627     }
12628   }
12629   jresult = result;
12630   return jresult;
12631 }
12632
12633
12634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12635   unsigned int jresult ;
12636   unsigned int arg1 ;
12637   unsigned int result;
12638
12639   arg1 = (unsigned int)jarg1;
12640   {
12641     try {
12642       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12643     } catch (std::out_of_range& e) {
12644       {
12645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12646       };
12647     } catch (std::exception& e) {
12648       {
12649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12650       };
12651     } catch (...) {
12652       {
12653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12654       };
12655     }
12656   }
12657   jresult = result;
12658   return jresult;
12659 }
12660
12661
12662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12663   unsigned int jresult ;
12664   unsigned int arg1 ;
12665   bool result;
12666
12667   arg1 = (unsigned int)jarg1;
12668   {
12669     try {
12670       result = (bool)Dali::IsPowerOfTwo(arg1);
12671     } catch (std::out_of_range& e) {
12672       {
12673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12674       };
12675     } catch (std::exception& e) {
12676       {
12677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12678       };
12679     } catch (...) {
12680       {
12681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12682       };
12683     }
12684   }
12685   jresult = result;
12686   return jresult;
12687 }
12688
12689
12690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12691   float jresult ;
12692   float arg1 ;
12693   float arg2 ;
12694   float result;
12695
12696   arg1 = (float)jarg1;
12697   arg2 = (float)jarg2;
12698   {
12699     try {
12700       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12701     } catch (std::out_of_range& e) {
12702       {
12703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12704       };
12705     } catch (std::exception& e) {
12706       {
12707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12708       };
12709     } catch (...) {
12710       {
12711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12712       };
12713     }
12714   }
12715   jresult = result;
12716   return jresult;
12717 }
12718
12719
12720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12721   unsigned int jresult ;
12722   float arg1 ;
12723   bool result;
12724
12725   arg1 = (float)jarg1;
12726   {
12727     try {
12728       result = (bool)Dali::EqualsZero(arg1);
12729     } catch (std::out_of_range& e) {
12730       {
12731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12732       };
12733     } catch (std::exception& e) {
12734       {
12735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12736       };
12737     } catch (...) {
12738       {
12739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12740       };
12741     }
12742   }
12743   jresult = result;
12744   return jresult;
12745 }
12746
12747
12748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12749   unsigned int jresult ;
12750   float arg1 ;
12751   float arg2 ;
12752   bool result;
12753
12754   arg1 = (float)jarg1;
12755   arg2 = (float)jarg2;
12756   {
12757     try {
12758       result = (bool)Dali::Equals(arg1,arg2);
12759     } catch (std::out_of_range& e) {
12760       {
12761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12762       };
12763     } catch (std::exception& e) {
12764       {
12765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12766       };
12767     } catch (...) {
12768       {
12769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12770       };
12771     }
12772   }
12773   jresult = result;
12774   return jresult;
12775 }
12776
12777
12778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12779   unsigned int jresult ;
12780   float arg1 ;
12781   float arg2 ;
12782   float arg3 ;
12783   bool result;
12784
12785   arg1 = (float)jarg1;
12786   arg2 = (float)jarg2;
12787   arg3 = (float)jarg3;
12788   {
12789     try {
12790       result = (bool)Dali::Equals(arg1,arg2,arg3);
12791     } catch (std::out_of_range& e) {
12792       {
12793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12794       };
12795     } catch (std::exception& e) {
12796       {
12797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12798       };
12799     } catch (...) {
12800       {
12801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12802       };
12803     }
12804   }
12805   jresult = result;
12806   return jresult;
12807 }
12808
12809
12810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12811   float jresult ;
12812   float arg1 ;
12813   int arg2 ;
12814   float result;
12815
12816   arg1 = (float)jarg1;
12817   arg2 = (int)jarg2;
12818   {
12819     try {
12820       result = (float)Dali::Round(arg1,arg2);
12821     } catch (std::out_of_range& e) {
12822       {
12823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12824       };
12825     } catch (std::exception& e) {
12826       {
12827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12828       };
12829     } catch (...) {
12830       {
12831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12832       };
12833     }
12834   }
12835   jresult = result;
12836   return jresult;
12837 }
12838
12839
12840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12841   float jresult ;
12842   float arg1 ;
12843   float arg2 ;
12844   float arg3 ;
12845   float result;
12846
12847   arg1 = (float)jarg1;
12848   arg2 = (float)jarg2;
12849   arg3 = (float)jarg3;
12850   {
12851     try {
12852       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12853     } catch (std::out_of_range& e) {
12854       {
12855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12856       };
12857     } catch (std::exception& e) {
12858       {
12859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12860       };
12861     } catch (...) {
12862       {
12863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12864       };
12865     }
12866   }
12867   jresult = result;
12868   return jresult;
12869 }
12870
12871
12872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12873   float jresult ;
12874   float arg1 ;
12875   float arg2 ;
12876   float arg3 ;
12877   float arg4 ;
12878   float result;
12879
12880   arg1 = (float)jarg1;
12881   arg2 = (float)jarg2;
12882   arg3 = (float)jarg3;
12883   arg4 = (float)jarg4;
12884   {
12885     try {
12886       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12887     } catch (std::out_of_range& e) {
12888       {
12889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12890       };
12891     } catch (std::exception& e) {
12892       {
12893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12894       };
12895     } catch (...) {
12896       {
12897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12898       };
12899     }
12900   }
12901   jresult = result;
12902   return jresult;
12903 }
12904
12905
12906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12907   int jresult ;
12908   int result;
12909
12910   result = (int)(int)Dali::Property::INVALID_INDEX;
12911   jresult = result;
12912   return jresult;
12913 }
12914
12915
12916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12917   int jresult ;
12918   int result;
12919
12920   result = (int)(int)Dali::Property::INVALID_KEY;
12921   jresult = result;
12922   return jresult;
12923 }
12924
12925
12926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12927   int jresult ;
12928   int result;
12929
12930   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12931   jresult = result;
12932   return jresult;
12933 }
12934
12935
12936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12937   void * jresult ;
12938   Dali::Handle *arg1 = 0 ;
12939   Dali::Property::Index arg2 ;
12940   Dali::Property *result = 0 ;
12941
12942   arg1 = (Dali::Handle *)jarg1;
12943   if (!arg1) {
12944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12945     return 0;
12946   }
12947   arg2 = (Dali::Property::Index)jarg2;
12948   {
12949     try {
12950       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12951     } catch (std::out_of_range& e) {
12952       {
12953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12954       };
12955     } catch (std::exception& e) {
12956       {
12957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12958       };
12959     } catch (...) {
12960       {
12961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12962       };
12963     }
12964   }
12965   jresult = (void *)result;
12966   return jresult;
12967 }
12968
12969
12970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12971   void * jresult ;
12972   Dali::Handle *arg1 = 0 ;
12973   Dali::Property::Index arg2 ;
12974   int arg3 ;
12975   Dali::Property *result = 0 ;
12976
12977   arg1 = (Dali::Handle *)jarg1;
12978   if (!arg1) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12980     return 0;
12981   }
12982   arg2 = (Dali::Property::Index)jarg2;
12983   arg3 = (int)jarg3;
12984   {
12985     try {
12986       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12987     } catch (std::out_of_range& e) {
12988       {
12989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12990       };
12991     } catch (std::exception& e) {
12992       {
12993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12994       };
12995     } catch (...) {
12996       {
12997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12998       };
12999     }
13000   }
13001   jresult = (void *)result;
13002   return jresult;
13003 }
13004
13005
13006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13007   void * jresult ;
13008   Dali::Handle *arg1 = 0 ;
13009   std::string *arg2 = 0 ;
13010   Dali::Property *result = 0 ;
13011
13012   arg1 = (Dali::Handle *)jarg1;
13013   if (!arg1) {
13014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13015     return 0;
13016   }
13017   if (!jarg2) {
13018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13019     return 0;
13020   }
13021   std::string arg2_str(jarg2);
13022   arg2 = &arg2_str;
13023   {
13024     try {
13025       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13026     } catch (std::out_of_range& e) {
13027       {
13028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13029       };
13030     } catch (std::exception& e) {
13031       {
13032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13033       };
13034     } catch (...) {
13035       {
13036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13037       };
13038     }
13039   }
13040   jresult = (void *)result;
13041
13042   //argout typemap for const std::string&
13043
13044   return jresult;
13045 }
13046
13047
13048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13049   void * jresult ;
13050   Dali::Handle *arg1 = 0 ;
13051   std::string *arg2 = 0 ;
13052   int arg3 ;
13053   Dali::Property *result = 0 ;
13054
13055   arg1 = (Dali::Handle *)jarg1;
13056   if (!arg1) {
13057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13058     return 0;
13059   }
13060   if (!jarg2) {
13061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13062     return 0;
13063   }
13064   std::string arg2_str(jarg2);
13065   arg2 = &arg2_str;
13066   arg3 = (int)jarg3;
13067   {
13068     try {
13069       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*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
13086   //argout typemap for const std::string&
13087
13088   return jresult;
13089 }
13090
13091
13092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13093   Dali::Property *arg1 = (Dali::Property *) 0 ;
13094
13095   arg1 = (Dali::Property *)jarg1;
13096   {
13097     try {
13098       delete arg1;
13099     } catch (std::out_of_range& e) {
13100       {
13101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13102       };
13103     } catch (std::exception& e) {
13104       {
13105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13106       };
13107     } catch (...) {
13108       {
13109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13110       };
13111     }
13112   }
13113 }
13114
13115
13116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13117   Dali::Property *arg1 = (Dali::Property *) 0 ;
13118   Dali::Handle *arg2 = 0 ;
13119
13120   arg1 = (Dali::Property *)jarg1;
13121   arg2 = (Dali::Handle *)jarg2;
13122   if (!arg2) {
13123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13124     return ;
13125   }
13126   if (arg1) (arg1)->object = *arg2;
13127 }
13128
13129
13130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13131   void * jresult ;
13132   Dali::Property *arg1 = (Dali::Property *) 0 ;
13133   Dali::Handle *result = 0 ;
13134
13135   arg1 = (Dali::Property *)jarg1;
13136   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13137   jresult = (void *)result;
13138   return jresult;
13139 }
13140
13141
13142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13143   Dali::Property *arg1 = (Dali::Property *) 0 ;
13144   Dali::Property::Index arg2 ;
13145
13146   arg1 = (Dali::Property *)jarg1;
13147   arg2 = (Dali::Property::Index)jarg2;
13148   if (arg1) (arg1)->propertyIndex = arg2;
13149 }
13150
13151
13152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13153   int jresult ;
13154   Dali::Property *arg1 = (Dali::Property *) 0 ;
13155   Dali::Property::Index result;
13156
13157   arg1 = (Dali::Property *)jarg1;
13158   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13159   jresult = result;
13160   return jresult;
13161 }
13162
13163
13164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13165   Dali::Property *arg1 = (Dali::Property *) 0 ;
13166   int arg2 ;
13167
13168   arg1 = (Dali::Property *)jarg1;
13169   arg2 = (int)jarg2;
13170   if (arg1) (arg1)->componentIndex = arg2;
13171 }
13172
13173
13174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13175   int jresult ;
13176   Dali::Property *arg1 = (Dali::Property *) 0 ;
13177   int result;
13178
13179   arg1 = (Dali::Property *)jarg1;
13180   result = (int) ((arg1)->componentIndex);
13181   jresult = result;
13182   return jresult;
13183 }
13184
13185
13186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13187   void * jresult ;
13188   Dali::Property::Array *result = 0 ;
13189
13190   {
13191     try {
13192       result = (Dali::Property::Array *)new Dali::Property::Array();
13193     } catch (std::out_of_range& e) {
13194       {
13195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13196       };
13197     } catch (std::exception& e) {
13198       {
13199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13200       };
13201     } catch (...) {
13202       {
13203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13204       };
13205     }
13206   }
13207   jresult = (void *)result;
13208   return jresult;
13209 }
13210
13211
13212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13213   void * jresult ;
13214   Dali::Property::Array *arg1 = 0 ;
13215   Dali::Property::Array *result = 0 ;
13216
13217   arg1 = (Dali::Property::Array *)jarg1;
13218   if (!arg1) {
13219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13220     return 0;
13221   }
13222   {
13223     try {
13224       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13225     } catch (std::out_of_range& e) {
13226       {
13227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13228       };
13229     } catch (std::exception& e) {
13230       {
13231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13232       };
13233     } catch (...) {
13234       {
13235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13236       };
13237     }
13238   }
13239   jresult = (void *)result;
13240   return jresult;
13241 }
13242
13243
13244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13245   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13246
13247   arg1 = (Dali::Property::Array *)jarg1;
13248   {
13249     try {
13250       delete arg1;
13251     } catch (std::out_of_range& e) {
13252       {
13253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13254       };
13255     } catch (std::exception& e) {
13256       {
13257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13258       };
13259     } catch (...) {
13260       {
13261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13262       };
13263     }
13264   }
13265 }
13266
13267
13268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13269   unsigned long jresult ;
13270   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13271   Dali::Property::Array::SizeType result;
13272
13273   arg1 = (Dali::Property::Array *)jarg1;
13274   {
13275     try {
13276       result = ((Dali::Property::Array const *)arg1)->Size();
13277     } catch (std::out_of_range& e) {
13278       {
13279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13280       };
13281     } catch (std::exception& e) {
13282       {
13283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13284       };
13285     } catch (...) {
13286       {
13287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13288       };
13289     }
13290   }
13291   jresult = (unsigned long)result;
13292   return jresult;
13293 }
13294
13295
13296 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13297   unsigned long jresult ;
13298   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13299   Dali::Property::Array::SizeType result;
13300
13301   arg1 = (Dali::Property::Array *)jarg1;
13302   {
13303     try {
13304       result = ((Dali::Property::Array const *)arg1)->Count();
13305     } catch (std::out_of_range& e) {
13306       {
13307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13308       };
13309     } catch (std::exception& e) {
13310       {
13311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13312       };
13313     } catch (...) {
13314       {
13315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13316       };
13317     }
13318   }
13319   jresult = (unsigned long)result;
13320   return jresult;
13321 }
13322
13323
13324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13325   unsigned int jresult ;
13326   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13327   bool result;
13328
13329   arg1 = (Dali::Property::Array *)jarg1;
13330   {
13331     try {
13332       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13333     } catch (std::out_of_range& e) {
13334       {
13335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13336       };
13337     } catch (std::exception& e) {
13338       {
13339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13340       };
13341     } catch (...) {
13342       {
13343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13344       };
13345     }
13346   }
13347   jresult = result;
13348   return jresult;
13349 }
13350
13351
13352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13353   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13354
13355   arg1 = (Dali::Property::Array *)jarg1;
13356   {
13357     try {
13358       (arg1)->Clear();
13359     } catch (std::out_of_range& e) {
13360       {
13361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13362       };
13363     } catch (std::exception& e) {
13364       {
13365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13366       };
13367     } catch (...) {
13368       {
13369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13370       };
13371     }
13372   }
13373 }
13374
13375
13376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13377   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13378   Dali::Property::Array::SizeType arg2 ;
13379
13380   arg1 = (Dali::Property::Array *)jarg1;
13381   arg2 = (Dali::Property::Array::SizeType)jarg2;
13382   {
13383     try {
13384       (arg1)->Reserve(arg2);
13385     } catch (std::out_of_range& e) {
13386       {
13387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13388       };
13389     } catch (std::exception& e) {
13390       {
13391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13392       };
13393     } catch (...) {
13394       {
13395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13396       };
13397     }
13398   }
13399 }
13400
13401
13402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13403   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13404   Dali::Property::Array::SizeType arg2 ;
13405
13406   arg1 = (Dali::Property::Array *)jarg1;
13407   arg2 = (Dali::Property::Array::SizeType)jarg2;
13408   {
13409     try {
13410       (arg1)->Resize(arg2);
13411     } catch (std::out_of_range& e) {
13412       {
13413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13414       };
13415     } catch (std::exception& e) {
13416       {
13417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13418       };
13419     } catch (...) {
13420       {
13421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13422       };
13423     }
13424   }
13425 }
13426
13427
13428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13429   unsigned long jresult ;
13430   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13431   Dali::Property::Array::SizeType result;
13432
13433   arg1 = (Dali::Property::Array *)jarg1;
13434   {
13435     try {
13436       result = (arg1)->Capacity();
13437     } catch (std::out_of_range& e) {
13438       {
13439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13440       };
13441     } catch (std::exception& e) {
13442       {
13443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13444       };
13445     } catch (...) {
13446       {
13447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13448       };
13449     }
13450   }
13451   jresult = (unsigned long)result;
13452   return jresult;
13453 }
13454
13455
13456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13457   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13458   Dali::Property::Value *arg2 = 0 ;
13459
13460   arg1 = (Dali::Property::Array *)jarg1;
13461   arg2 = (Dali::Property::Value *)jarg2;
13462   if (!arg2) {
13463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13464     return ;
13465   }
13466   {
13467     try {
13468       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13469     } catch (std::out_of_range& e) {
13470       {
13471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13472       };
13473     } catch (std::exception& e) {
13474       {
13475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13476       };
13477     } catch (...) {
13478       {
13479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13480       };
13481     }
13482   }
13483 }
13484
13485
13486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13487   void * jresult ;
13488   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13489   Dali::Property::Value *arg2 = 0 ;
13490   Dali::Property::Array *result = 0 ;
13491
13492   arg1 = (Dali::Property::Array *)jarg1;
13493   arg2 = (Dali::Property::Value *)jarg2;
13494   if (!arg2) {
13495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13496     return 0;
13497   }
13498   {
13499     try {
13500       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13501     } catch (std::out_of_range& e) {
13502       {
13503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13504       };
13505     } catch (std::exception& e) {
13506       {
13507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13508       };
13509     } catch (...) {
13510       {
13511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13512       };
13513     }
13514   }
13515   jresult = (void *)result;
13516   return jresult;
13517 }
13518
13519
13520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13521   void * jresult ;
13522   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13523   Dali::Property::Array::SizeType arg2 ;
13524   Dali::Property::Value *result = 0 ;
13525
13526   arg1 = (Dali::Property::Array *)jarg1;
13527   arg2 = (Dali::Property::Array::SizeType)jarg2;
13528   {
13529     try {
13530       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13531     } catch (std::out_of_range& e) {
13532       {
13533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13534       };
13535     } catch (std::exception& e) {
13536       {
13537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (...) {
13540       {
13541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13542       };
13543     }
13544   }
13545   jresult = (void *)result;
13546   return jresult;
13547 }
13548
13549
13550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13551   void * jresult ;
13552   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13553   Dali::Property::Array::SizeType arg2 ;
13554   Dali::Property::Value *result = 0 ;
13555
13556   arg1 = (Dali::Property::Array *)jarg1;
13557   arg2 = (Dali::Property::Array::SizeType)jarg2;
13558   {
13559     try {
13560       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13561     } catch (std::out_of_range& e) {
13562       {
13563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13564       };
13565     } catch (std::exception& e) {
13566       {
13567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13568       };
13569     } catch (...) {
13570       {
13571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13572       };
13573     }
13574   }
13575   jresult = (void *)result;
13576   return jresult;
13577 }
13578
13579
13580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13581   void * jresult ;
13582   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13583   Dali::Property::Array *arg2 = 0 ;
13584   Dali::Property::Array *result = 0 ;
13585
13586   arg1 = (Dali::Property::Array *)jarg1;
13587   arg2 = (Dali::Property::Array *)jarg2;
13588   if (!arg2) {
13589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13590     return 0;
13591   }
13592   {
13593     try {
13594       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13595     } catch (std::out_of_range& e) {
13596       {
13597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13598       };
13599     } catch (std::exception& e) {
13600       {
13601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13602       };
13603     } catch (...) {
13604       {
13605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13606       };
13607     }
13608   }
13609   jresult = (void *)result;
13610   return jresult;
13611 }
13612
13613
13614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13615   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13616   enum Dali::Property::Key::Type arg2 ;
13617
13618   arg1 = (Dali::Property::Key *)jarg1;
13619   arg2 = (enum Dali::Property::Key::Type)jarg2;
13620   if (arg1) (arg1)->type = arg2;
13621 }
13622
13623
13624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13625   int jresult ;
13626   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13627   enum Dali::Property::Key::Type result;
13628
13629   arg1 = (Dali::Property::Key *)jarg1;
13630   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13631   jresult = (int)result;
13632   return jresult;
13633 }
13634
13635
13636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13637   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13638   Dali::Property::Index arg2 ;
13639
13640   arg1 = (Dali::Property::Key *)jarg1;
13641   arg2 = (Dali::Property::Index)jarg2;
13642   if (arg1) (arg1)->indexKey = arg2;
13643 }
13644
13645
13646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13647   int jresult ;
13648   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13649   Dali::Property::Index result;
13650
13651   arg1 = (Dali::Property::Key *)jarg1;
13652   result = (Dali::Property::Index) ((arg1)->indexKey);
13653   jresult = result;
13654   return jresult;
13655 }
13656
13657
13658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13659   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13660   std::string *arg2 = 0 ;
13661
13662   arg1 = (Dali::Property::Key *)jarg1;
13663   if (!jarg2) {
13664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13665     return ;
13666   }
13667   std::string arg2_str(jarg2);
13668   arg2 = &arg2_str;
13669   if (arg1) (arg1)->stringKey = *arg2;
13670
13671   //argout typemap for const std::string&
13672
13673 }
13674
13675
13676 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13677   char * jresult ;
13678   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13679   std::string *result = 0 ;
13680
13681   arg1 = (Dali::Property::Key *)jarg1;
13682   result = (std::string *) & ((arg1)->stringKey);
13683   jresult = SWIG_csharp_string_callback(result->c_str());
13684   return jresult;
13685 }
13686
13687
13688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13689   void * jresult ;
13690   std::string *arg1 = 0 ;
13691   Dali::Property::Key *result = 0 ;
13692
13693   if (!jarg1) {
13694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13695     return 0;
13696   }
13697   std::string arg1_str(jarg1);
13698   arg1 = &arg1_str;
13699   {
13700     try {
13701       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13702     } catch (std::out_of_range& e) {
13703       {
13704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13705       };
13706     } catch (std::exception& e) {
13707       {
13708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13709       };
13710     } catch (...) {
13711       {
13712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13713       };
13714     }
13715   }
13716   jresult = (void *)result;
13717
13718   //argout typemap for const std::string&
13719
13720   return jresult;
13721 }
13722
13723
13724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13725   void * jresult ;
13726   Dali::Property::Index arg1 ;
13727   Dali::Property::Key *result = 0 ;
13728
13729   arg1 = (Dali::Property::Index)jarg1;
13730   {
13731     try {
13732       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13733     } catch (std::out_of_range& e) {
13734       {
13735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13736       };
13737     } catch (std::exception& e) {
13738       {
13739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13740       };
13741     } catch (...) {
13742       {
13743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13744       };
13745     }
13746   }
13747   jresult = (void *)result;
13748   return jresult;
13749 }
13750
13751
13752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13753   unsigned int jresult ;
13754   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13755   std::string *arg2 = 0 ;
13756   bool result;
13757
13758   arg1 = (Dali::Property::Key *)jarg1;
13759   if (!jarg2) {
13760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13761     return 0;
13762   }
13763   std::string arg2_str(jarg2);
13764   arg2 = &arg2_str;
13765   {
13766     try {
13767       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13768     } catch (std::out_of_range& e) {
13769       {
13770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13771       };
13772     } catch (std::exception& e) {
13773       {
13774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13775       };
13776     } catch (...) {
13777       {
13778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13779       };
13780     }
13781   }
13782   jresult = result;
13783
13784   //argout typemap for const std::string&
13785
13786   return jresult;
13787 }
13788
13789
13790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13791   unsigned int jresult ;
13792   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13793   Dali::Property::Index arg2 ;
13794   bool result;
13795
13796   arg1 = (Dali::Property::Key *)jarg1;
13797   arg2 = (Dali::Property::Index)jarg2;
13798   {
13799     try {
13800       result = (bool)(arg1)->operator ==(arg2);
13801     } catch (std::out_of_range& e) {
13802       {
13803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13804       };
13805     } catch (std::exception& e) {
13806       {
13807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13808       };
13809     } catch (...) {
13810       {
13811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13812       };
13813     }
13814   }
13815   jresult = result;
13816   return jresult;
13817 }
13818
13819
13820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13821   unsigned int jresult ;
13822   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13823   Dali::Property::Key *arg2 = 0 ;
13824   bool result;
13825
13826   arg1 = (Dali::Property::Key *)jarg1;
13827   arg2 = (Dali::Property::Key *)jarg2;
13828   if (!arg2) {
13829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13830     return 0;
13831   }
13832   {
13833     try {
13834       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13835     } catch (std::out_of_range& e) {
13836       {
13837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13838       };
13839     } catch (std::exception& e) {
13840       {
13841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13842       };
13843     } catch (...) {
13844       {
13845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13846       };
13847     }
13848   }
13849   jresult = result;
13850   return jresult;
13851 }
13852
13853
13854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13855   unsigned int jresult ;
13856   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13857   std::string *arg2 = 0 ;
13858   bool result;
13859
13860   arg1 = (Dali::Property::Key *)jarg1;
13861   if (!jarg2) {
13862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13863     return 0;
13864   }
13865   std::string arg2_str(jarg2);
13866   arg2 = &arg2_str;
13867   {
13868     try {
13869       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13870     } catch (std::out_of_range& e) {
13871       {
13872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13873       };
13874     } catch (std::exception& e) {
13875       {
13876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13877       };
13878     } catch (...) {
13879       {
13880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13881       };
13882     }
13883   }
13884   jresult = result;
13885
13886   //argout typemap for const std::string&
13887
13888   return jresult;
13889 }
13890
13891
13892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13893   unsigned int jresult ;
13894   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13895   Dali::Property::Index arg2 ;
13896   bool result;
13897
13898   arg1 = (Dali::Property::Key *)jarg1;
13899   arg2 = (Dali::Property::Index)jarg2;
13900   {
13901     try {
13902       result = (bool)(arg1)->operator !=(arg2);
13903     } catch (std::out_of_range& e) {
13904       {
13905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13906       };
13907     } catch (std::exception& e) {
13908       {
13909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13910       };
13911     } catch (...) {
13912       {
13913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13914       };
13915     }
13916   }
13917   jresult = result;
13918   return jresult;
13919 }
13920
13921
13922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13923   unsigned int jresult ;
13924   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13925   Dali::Property::Key *arg2 = 0 ;
13926   bool result;
13927
13928   arg1 = (Dali::Property::Key *)jarg1;
13929   arg2 = (Dali::Property::Key *)jarg2;
13930   if (!arg2) {
13931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13932     return 0;
13933   }
13934   {
13935     try {
13936       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13937     } catch (std::out_of_range& e) {
13938       {
13939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13940       };
13941     } catch (std::exception& e) {
13942       {
13943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13944       };
13945     } catch (...) {
13946       {
13947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13948       };
13949     }
13950   }
13951   jresult = result;
13952   return jresult;
13953 }
13954
13955
13956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13957   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13958
13959   arg1 = (Dali::Property::Key *)jarg1;
13960   {
13961     try {
13962       delete arg1;
13963     } catch (std::out_of_range& e) {
13964       {
13965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13966       };
13967     } catch (std::exception& e) {
13968       {
13969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13970       };
13971     } catch (...) {
13972       {
13973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13974       };
13975     }
13976   }
13977 }
13978
13979
13980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13981   void * jresult ;
13982   Dali::Property::Map *result = 0 ;
13983
13984   {
13985     try {
13986       result = (Dali::Property::Map *)new Dali::Property::Map();
13987     } catch (std::out_of_range& e) {
13988       {
13989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13990       };
13991     } catch (std::exception& e) {
13992       {
13993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13994       };
13995     } catch (...) {
13996       {
13997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13998       };
13999     }
14000   }
14001   jresult = (void *)result;
14002   return jresult;
14003 }
14004
14005
14006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14007   void * jresult ;
14008   Dali::Property::Map *arg1 = 0 ;
14009   Dali::Property::Map *result = 0 ;
14010
14011   arg1 = (Dali::Property::Map *)jarg1;
14012   if (!arg1) {
14013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14014     return 0;
14015   }
14016   {
14017     try {
14018       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14019     } catch (std::out_of_range& e) {
14020       {
14021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14022       };
14023     } catch (std::exception& e) {
14024       {
14025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14026       };
14027     } catch (...) {
14028       {
14029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14030       };
14031     }
14032   }
14033   jresult = (void *)result;
14034   return jresult;
14035 }
14036
14037
14038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14039   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14040
14041   arg1 = (Dali::Property::Map *)jarg1;
14042   {
14043     try {
14044       delete arg1;
14045     } catch (std::out_of_range& e) {
14046       {
14047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14048       };
14049     } catch (std::exception& e) {
14050       {
14051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14052       };
14053     } catch (...) {
14054       {
14055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14056       };
14057     }
14058   }
14059 }
14060
14061
14062 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14063   unsigned long jresult ;
14064   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14065   Dali::Property::Map::SizeType result;
14066
14067   arg1 = (Dali::Property::Map *)jarg1;
14068   {
14069     try {
14070       result = ((Dali::Property::Map const *)arg1)->Count();
14071     } catch (std::out_of_range& e) {
14072       {
14073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14074       };
14075     } catch (std::exception& e) {
14076       {
14077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14078       };
14079     } catch (...) {
14080       {
14081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14082       };
14083     }
14084   }
14085   jresult = (unsigned long)result;
14086   return jresult;
14087 }
14088
14089
14090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14091   unsigned int jresult ;
14092   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14093   bool result;
14094
14095   arg1 = (Dali::Property::Map *)jarg1;
14096   {
14097     try {
14098       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14099     } catch (std::out_of_range& e) {
14100       {
14101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14102       };
14103     } catch (std::exception& e) {
14104       {
14105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14106       };
14107     } catch (...) {
14108       {
14109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14110       };
14111     }
14112   }
14113   jresult = result;
14114   return jresult;
14115 }
14116
14117
14118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14119   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14120   char *arg2 = (char *) 0 ;
14121   Dali::Property::Value *arg3 = 0 ;
14122
14123   arg1 = (Dali::Property::Map *)jarg1;
14124   arg2 = (char *)jarg2;
14125   arg3 = (Dali::Property::Value *)jarg3;
14126   if (!arg3) {
14127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14128     return ;
14129   }
14130   {
14131     try {
14132       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14133     } catch (std::out_of_range& e) {
14134       {
14135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14136       };
14137     } catch (std::exception& e) {
14138       {
14139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14140       };
14141     } catch (...) {
14142       {
14143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14144       };
14145     }
14146   }
14147 }
14148
14149
14150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14151   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14152   Dali::Property::Index arg2 ;
14153   Dali::Property::Value *arg3 = 0 ;
14154
14155   arg1 = (Dali::Property::Map *)jarg1;
14156   arg2 = (Dali::Property::Index)jarg2;
14157   arg3 = (Dali::Property::Value *)jarg3;
14158   if (!arg3) {
14159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14160     return ;
14161   }
14162   {
14163     try {
14164       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14165     } catch (std::out_of_range& e) {
14166       {
14167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14168       };
14169     } catch (std::exception& e) {
14170       {
14171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14172       };
14173     } catch (...) {
14174       {
14175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14176       };
14177     }
14178   }
14179 }
14180
14181
14182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14183   void * jresult ;
14184   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14185   char *arg2 = (char *) 0 ;
14186   Dali::Property::Value *arg3 = 0 ;
14187   Dali::Property::Map *result = 0 ;
14188
14189   arg1 = (Dali::Property::Map *)jarg1;
14190   arg2 = (char *)jarg2;
14191   arg3 = (Dali::Property::Value *)jarg3;
14192   if (!arg3) {
14193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14194     return 0;
14195   }
14196   {
14197     try {
14198       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14199     } catch (std::out_of_range& e) {
14200       {
14201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14202       };
14203     } catch (std::exception& e) {
14204       {
14205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14206       };
14207     } catch (...) {
14208       {
14209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14210       };
14211     }
14212   }
14213   jresult = (void *)result;
14214   return jresult;
14215 }
14216
14217
14218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14219   void * jresult ;
14220   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14221   Dali::Property::Index arg2 ;
14222   Dali::Property::Value *arg3 = 0 ;
14223   Dali::Property::Map *result = 0 ;
14224
14225   arg1 = (Dali::Property::Map *)jarg1;
14226   arg2 = (Dali::Property::Index)jarg2;
14227   arg3 = (Dali::Property::Value *)jarg3;
14228   if (!arg3) {
14229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14230     return 0;
14231   }
14232   {
14233     try {
14234       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14235     } catch (std::out_of_range& e) {
14236       {
14237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14238       };
14239     } catch (std::exception& e) {
14240       {
14241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14242       };
14243     } catch (...) {
14244       {
14245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14246       };
14247     }
14248   }
14249   jresult = (void *)result;
14250   return jresult;
14251 }
14252
14253
14254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14255   void * jresult ;
14256   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14257   Dali::Property::Map::SizeType arg2 ;
14258   Dali::Property::Value *result = 0 ;
14259
14260   arg1 = (Dali::Property::Map *)jarg1;
14261   arg2 = (Dali::Property::Map::SizeType)jarg2;
14262   {
14263     try {
14264       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14265     } catch (std::out_of_range& e) {
14266       {
14267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14268       };
14269     } catch (std::exception& e) {
14270       {
14271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14272       };
14273     } catch (...) {
14274       {
14275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14276       };
14277     }
14278   }
14279   jresult = (void *)result;
14280   return jresult;
14281 }
14282
14283
14284 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14285   char * jresult ;
14286   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14287   Dali::Property::Map::SizeType arg2 ;
14288   std::string *result = 0 ;
14289
14290   arg1 = (Dali::Property::Map *)jarg1;
14291   arg2 = (Dali::Property::Map::SizeType)jarg2;
14292   {
14293     try {
14294       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14295     } catch (std::out_of_range& e) {
14296       {
14297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14298       };
14299     } catch (std::exception& e) {
14300       {
14301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14302       };
14303     } catch (...) {
14304       {
14305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14306       };
14307     }
14308   }
14309   jresult = SWIG_csharp_string_callback(result->c_str());
14310   return jresult;
14311 }
14312
14313
14314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14315   void * jresult ;
14316   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14317   Dali::Property::Map::SizeType arg2 ;
14318   SwigValueWrapper< Dali::Property::Key > result;
14319
14320   arg1 = (Dali::Property::Map *)jarg1;
14321   arg2 = (Dali::Property::Map::SizeType)jarg2;
14322   {
14323     try {
14324       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14325     } catch (std::out_of_range& e) {
14326       {
14327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14328       };
14329     } catch (std::exception& e) {
14330       {
14331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14332       };
14333     } catch (...) {
14334       {
14335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14336       };
14337     }
14338   }
14339   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14340   return jresult;
14341 }
14342
14343
14344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14345   void * jresult ;
14346   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14347   Dali::Property::Map::SizeType arg2 ;
14348   StringValuePair *result = 0 ;
14349
14350   arg1 = (Dali::Property::Map *)jarg1;
14351   arg2 = (Dali::Property::Map::SizeType)jarg2;
14352   {
14353     try {
14354       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14355     } catch (std::out_of_range& e) {
14356       {
14357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (std::exception& e) {
14360       {
14361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369   jresult = (void *)result;
14370   return jresult;
14371 }
14372
14373
14374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14375   void * jresult ;
14376   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14377   char *arg2 = (char *) 0 ;
14378   Dali::Property::Value *result = 0 ;
14379
14380   arg1 = (Dali::Property::Map *)jarg1;
14381   arg2 = (char *)jarg2;
14382   {
14383     try {
14384       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14385     } catch (std::out_of_range& e) {
14386       {
14387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (std::exception& e) {
14390       {
14391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399   jresult = (void *)result;
14400   return jresult;
14401 }
14402
14403
14404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14405   void * jresult ;
14406   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14407   Dali::Property::Index arg2 ;
14408   Dali::Property::Value *result = 0 ;
14409
14410   arg1 = (Dali::Property::Map *)jarg1;
14411   arg2 = (Dali::Property::Index)jarg2;
14412   {
14413     try {
14414       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14415     } catch (std::out_of_range& e) {
14416       {
14417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (std::exception& e) {
14420       {
14421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (...) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14426       };
14427     }
14428   }
14429   jresult = (void *)result;
14430   return jresult;
14431 }
14432
14433
14434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14435   void * jresult ;
14436   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14437   Dali::Property::Index arg2 ;
14438   std::string *arg3 = 0 ;
14439   Dali::Property::Value *result = 0 ;
14440
14441   arg1 = (Dali::Property::Map *)jarg1;
14442   arg2 = (Dali::Property::Index)jarg2;
14443   if (!jarg3) {
14444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14445     return 0;
14446   }
14447   std::string arg3_str(jarg3);
14448   arg3 = &arg3_str;
14449   {
14450     try {
14451       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14452     } catch (std::out_of_range& e) {
14453       {
14454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14455       };
14456     } catch (std::exception& e) {
14457       {
14458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (...) {
14461       {
14462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14463       };
14464     }
14465   }
14466   jresult = (void *)result;
14467
14468   //argout typemap for const std::string&
14469
14470   return jresult;
14471 }
14472
14473
14474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14475   void * jresult ;
14476   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14477   std::string *arg2 = 0 ;
14478   Dali::Property::Type arg3 ;
14479   Dali::Property::Value *result = 0 ;
14480
14481   arg1 = (Dali::Property::Map *)jarg1;
14482   if (!jarg2) {
14483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14484     return 0;
14485   }
14486   std::string arg2_str(jarg2);
14487   arg2 = &arg2_str;
14488   arg3 = (Dali::Property::Type)jarg3;
14489   {
14490     try {
14491       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14492     } catch (std::out_of_range& e) {
14493       {
14494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14495       };
14496     } catch (std::exception& e) {
14497       {
14498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14499       };
14500     } catch (...) {
14501       {
14502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14503       };
14504     }
14505   }
14506   jresult = (void *)result;
14507
14508   //argout typemap for const std::string&
14509
14510   return jresult;
14511 }
14512
14513
14514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14515   void * jresult ;
14516   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14517   Dali::Property::Index arg2 ;
14518   Dali::Property::Type arg3 ;
14519   Dali::Property::Value *result = 0 ;
14520
14521   arg1 = (Dali::Property::Map *)jarg1;
14522   arg2 = (Dali::Property::Index)jarg2;
14523   arg3 = (Dali::Property::Type)jarg3;
14524   {
14525     try {
14526       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14527     } catch (std::out_of_range& e) {
14528       {
14529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14530       };
14531     } catch (std::exception& e) {
14532       {
14533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14534       };
14535     } catch (...) {
14536       {
14537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14538       };
14539     }
14540   }
14541   jresult = (void *)result;
14542   return jresult;
14543 }
14544
14545
14546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14547   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14548
14549   arg1 = (Dali::Property::Map *)jarg1;
14550   {
14551     try {
14552       (arg1)->Clear();
14553     } catch (std::out_of_range& e) {
14554       {
14555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14556       };
14557     } catch (std::exception& e) {
14558       {
14559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14560       };
14561     } catch (...) {
14562       {
14563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14564       };
14565     }
14566   }
14567 }
14568
14569
14570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14571   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14572   Dali::Property::Map *arg2 = 0 ;
14573
14574   arg1 = (Dali::Property::Map *)jarg1;
14575   arg2 = (Dali::Property::Map *)jarg2;
14576   if (!arg2) {
14577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14578     return ;
14579   }
14580   {
14581     try {
14582       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14583     } catch (std::out_of_range& e) {
14584       {
14585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14586       };
14587     } catch (std::exception& e) {
14588       {
14589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14590       };
14591     } catch (...) {
14592       {
14593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14594       };
14595     }
14596   }
14597 }
14598
14599
14600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14601   void * jresult ;
14602   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14603   std::string *arg2 = 0 ;
14604   Dali::Property::Value *result = 0 ;
14605
14606   arg1 = (Dali::Property::Map *)jarg1;
14607   if (!jarg2) {
14608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14609     return 0;
14610   }
14611   std::string arg2_str(jarg2);
14612   arg2 = &arg2_str;
14613   {
14614     try {
14615       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14616     } catch (std::out_of_range& e) {
14617       {
14618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14619       };
14620     } catch (std::exception& e) {
14621       {
14622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14623       };
14624     } catch (...) {
14625       {
14626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14627       };
14628     }
14629   }
14630   jresult = (void *)result;
14631
14632   //argout typemap for const std::string&
14633
14634   return jresult;
14635 }
14636
14637
14638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14639   void * jresult ;
14640   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14641   Dali::Property::Index arg2 ;
14642   Dali::Property::Value *result = 0 ;
14643
14644   arg1 = (Dali::Property::Map *)jarg1;
14645   arg2 = (Dali::Property::Index)jarg2;
14646   {
14647     try {
14648       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14649     } catch (std::out_of_range& e) {
14650       {
14651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14652       };
14653     } catch (std::exception& e) {
14654       {
14655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14656       };
14657     } catch (...) {
14658       {
14659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14660       };
14661     }
14662   }
14663   jresult = (void *)result;
14664   return jresult;
14665 }
14666
14667
14668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14669   void * jresult ;
14670   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14671   Dali::Property::Map *arg2 = 0 ;
14672   Dali::Property::Map *result = 0 ;
14673
14674   arg1 = (Dali::Property::Map *)jarg1;
14675   arg2 = (Dali::Property::Map *)jarg2;
14676   if (!arg2) {
14677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14678     return 0;
14679   }
14680   {
14681     try {
14682       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14683     } catch (std::out_of_range& e) {
14684       {
14685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14686       };
14687     } catch (std::exception& e) {
14688       {
14689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14690       };
14691     } catch (...) {
14692       {
14693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14694       };
14695     }
14696   }
14697   jresult = (void *)result;
14698   return jresult;
14699 }
14700
14701
14702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14703   void * jresult ;
14704   Dali::Property::Value *result = 0 ;
14705
14706   {
14707     try {
14708       result = (Dali::Property::Value *)new Dali::Property::Value();
14709     } catch (std::out_of_range& e) {
14710       {
14711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14712       };
14713     } catch (std::exception& e) {
14714       {
14715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14716       };
14717     } catch (...) {
14718       {
14719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14720       };
14721     }
14722   }
14723   jresult = (void *)result;
14724   return jresult;
14725 }
14726
14727
14728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14729   void * jresult ;
14730   bool arg1 ;
14731   Dali::Property::Value *result = 0 ;
14732
14733   arg1 = jarg1 ? true : false;
14734   {
14735     try {
14736       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14737     } catch (std::out_of_range& e) {
14738       {
14739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14740       };
14741     } catch (std::exception& e) {
14742       {
14743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14744       };
14745     } catch (...) {
14746       {
14747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14748       };
14749     }
14750   }
14751   jresult = (void *)result;
14752   return jresult;
14753 }
14754
14755
14756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14757   void * jresult ;
14758   int arg1 ;
14759   Dali::Property::Value *result = 0 ;
14760
14761   arg1 = (int)jarg1;
14762   {
14763     try {
14764       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14765     } catch (std::out_of_range& e) {
14766       {
14767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14768       };
14769     } catch (std::exception& e) {
14770       {
14771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (...) {
14774       {
14775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14776       };
14777     }
14778   }
14779   jresult = (void *)result;
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14785   void * jresult ;
14786   float arg1 ;
14787   Dali::Property::Value *result = 0 ;
14788
14789   arg1 = (float)jarg1;
14790   {
14791     try {
14792       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14793     } catch (std::out_of_range& e) {
14794       {
14795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14796       };
14797     } catch (std::exception& e) {
14798       {
14799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14800       };
14801     } catch (...) {
14802       {
14803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14804       };
14805     }
14806   }
14807   jresult = (void *)result;
14808   return jresult;
14809 }
14810
14811
14812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14813   void * jresult ;
14814   Dali::Vector2 *arg1 = 0 ;
14815   Dali::Property::Value *result = 0 ;
14816
14817   arg1 = (Dali::Vector2 *)jarg1;
14818   if (!arg1) {
14819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14820     return 0;
14821   }
14822   {
14823     try {
14824       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14825     } catch (std::out_of_range& e) {
14826       {
14827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14828       };
14829     } catch (std::exception& e) {
14830       {
14831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14832       };
14833     } catch (...) {
14834       {
14835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14836       };
14837     }
14838   }
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14845   void * jresult ;
14846   Dali::Vector3 *arg1 = 0 ;
14847   Dali::Property::Value *result = 0 ;
14848
14849   arg1 = (Dali::Vector3 *)jarg1;
14850   if (!arg1) {
14851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14852     return 0;
14853   }
14854   {
14855     try {
14856       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14857     } catch (std::out_of_range& e) {
14858       {
14859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14860       };
14861     } catch (std::exception& e) {
14862       {
14863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14864       };
14865     } catch (...) {
14866       {
14867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14868       };
14869     }
14870   }
14871   jresult = (void *)result;
14872   return jresult;
14873 }
14874
14875
14876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14877   void * jresult ;
14878   Dali::Vector4 *arg1 = 0 ;
14879   Dali::Property::Value *result = 0 ;
14880
14881   arg1 = (Dali::Vector4 *)jarg1;
14882   if (!arg1) {
14883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14884     return 0;
14885   }
14886   {
14887     try {
14888       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14889     } catch (std::out_of_range& e) {
14890       {
14891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (std::exception& e) {
14894       {
14895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14896       };
14897     } catch (...) {
14898       {
14899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14900       };
14901     }
14902   }
14903   jresult = (void *)result;
14904   return jresult;
14905 }
14906
14907
14908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14909   void * jresult ;
14910   Dali::Matrix3 *arg1 = 0 ;
14911   Dali::Property::Value *result = 0 ;
14912
14913   arg1 = (Dali::Matrix3 *)jarg1;
14914   if (!arg1) {
14915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14916     return 0;
14917   }
14918   {
14919     try {
14920       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14921     } catch (std::out_of_range& e) {
14922       {
14923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14924       };
14925     } catch (std::exception& e) {
14926       {
14927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14928       };
14929     } catch (...) {
14930       {
14931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14932       };
14933     }
14934   }
14935   jresult = (void *)result;
14936   return jresult;
14937 }
14938
14939
14940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14941   void * jresult ;
14942   Dali::Matrix *arg1 = 0 ;
14943   Dali::Property::Value *result = 0 ;
14944
14945   arg1 = (Dali::Matrix *)jarg1;
14946   if (!arg1) {
14947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14948     return 0;
14949   }
14950   {
14951     try {
14952       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14953     } catch (std::out_of_range& e) {
14954       {
14955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14956       };
14957     } catch (std::exception& e) {
14958       {
14959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14960       };
14961     } catch (...) {
14962       {
14963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14964       };
14965     }
14966   }
14967   jresult = (void *)result;
14968   return jresult;
14969 }
14970
14971
14972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14973   void * jresult ;
14974   Dali::Rect< int > *arg1 = 0 ;
14975   Dali::Property::Value *result = 0 ;
14976
14977   arg1 = (Dali::Rect< int > *)jarg1;
14978   if (!arg1) {
14979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14980     return 0;
14981   }
14982   {
14983     try {
14984       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14985     } catch (std::out_of_range& e) {
14986       {
14987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14988       };
14989     } catch (std::exception& e) {
14990       {
14991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14992       };
14993     } catch (...) {
14994       {
14995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14996       };
14997     }
14998   }
14999   jresult = (void *)result;
15000   return jresult;
15001 }
15002
15003
15004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15005   void * jresult ;
15006   Dali::AngleAxis *arg1 = 0 ;
15007   Dali::Property::Value *result = 0 ;
15008
15009   arg1 = (Dali::AngleAxis *)jarg1;
15010   if (!arg1) {
15011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15012     return 0;
15013   }
15014   {
15015     try {
15016       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15017     } catch (std::out_of_range& e) {
15018       {
15019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15020       };
15021     } catch (std::exception& e) {
15022       {
15023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15024       };
15025     } catch (...) {
15026       {
15027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15028       };
15029     }
15030   }
15031   jresult = (void *)result;
15032   return jresult;
15033 }
15034
15035
15036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15037   void * jresult ;
15038   Dali::Quaternion *arg1 = 0 ;
15039   Dali::Property::Value *result = 0 ;
15040
15041   arg1 = (Dali::Quaternion *)jarg1;
15042   if (!arg1) {
15043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15044     return 0;
15045   }
15046   {
15047     try {
15048       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15049     } catch (std::out_of_range& e) {
15050       {
15051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15052       };
15053     } catch (std::exception& e) {
15054       {
15055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15056       };
15057     } catch (...) {
15058       {
15059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15060       };
15061     }
15062   }
15063   jresult = (void *)result;
15064   return jresult;
15065 }
15066
15067
15068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15069   void * jresult ;
15070   std::string *arg1 = 0 ;
15071   Dali::Property::Value *result = 0 ;
15072
15073   if (!jarg1) {
15074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15075     return 0;
15076   }
15077   std::string arg1_str(jarg1);
15078   arg1 = &arg1_str;
15079   {
15080     try {
15081       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15082     } catch (std::out_of_range& e) {
15083       {
15084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15085       };
15086     } catch (std::exception& e) {
15087       {
15088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15089       };
15090     } catch (...) {
15091       {
15092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15093       };
15094     }
15095   }
15096   jresult = (void *)result;
15097
15098   //argout typemap for const std::string&
15099
15100   return jresult;
15101 }
15102
15103
15104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15105   void * jresult ;
15106   Dali::Property::Array *arg1 = 0 ;
15107   Dali::Property::Value *result = 0 ;
15108
15109   arg1 = (Dali::Property::Array *)jarg1;
15110   if (!arg1) {
15111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15112     return 0;
15113   }
15114   {
15115     try {
15116       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15117     } catch (std::out_of_range& e) {
15118       {
15119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15120       };
15121     } catch (std::exception& e) {
15122       {
15123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15124       };
15125     } catch (...) {
15126       {
15127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15128       };
15129     }
15130   }
15131   jresult = (void *)result;
15132   return jresult;
15133 }
15134
15135
15136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15137   void * jresult ;
15138   Dali::Property::Map *arg1 = 0 ;
15139   Dali::Property::Value *result = 0 ;
15140
15141   arg1 = (Dali::Property::Map *)jarg1;
15142   if (!arg1) {
15143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15144     return 0;
15145   }
15146   {
15147     try {
15148       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15149     } catch (std::out_of_range& e) {
15150       {
15151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15152       };
15153     } catch (std::exception& e) {
15154       {
15155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15156       };
15157     } catch (...) {
15158       {
15159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15160       };
15161     }
15162   }
15163   jresult = (void *)result;
15164   return jresult;
15165 }
15166
15167
15168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15169   void * jresult ;
15170   Dali::Property::Type arg1 ;
15171   Dali::Property::Value *result = 0 ;
15172
15173   arg1 = (Dali::Property::Type)jarg1;
15174   {
15175     try {
15176       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15177     } catch (std::out_of_range& e) {
15178       {
15179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15180       };
15181     } catch (std::exception& e) {
15182       {
15183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15184       };
15185     } catch (...) {
15186       {
15187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15188       };
15189     }
15190   }
15191   jresult = (void *)result;
15192   return jresult;
15193 }
15194
15195
15196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15197   void * jresult ;
15198   Dali::Property::Value *arg1 = 0 ;
15199   Dali::Property::Value *result = 0 ;
15200
15201   arg1 = (Dali::Property::Value *)jarg1;
15202   if (!arg1) {
15203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15204     return 0;
15205   }
15206   {
15207     try {
15208       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15209     } catch (std::out_of_range& e) {
15210       {
15211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15212       };
15213     } catch (std::exception& e) {
15214       {
15215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15216       };
15217     } catch (...) {
15218       {
15219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15220       };
15221     }
15222   }
15223   jresult = (void *)result;
15224   return jresult;
15225 }
15226
15227
15228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15229   void * jresult ;
15230   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15231   Dali::Property::Value *arg2 = 0 ;
15232   Dali::Property::Value *result = 0 ;
15233
15234   arg1 = (Dali::Property::Value *)jarg1;
15235   arg2 = (Dali::Property::Value *)jarg2;
15236   if (!arg2) {
15237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15238     return 0;
15239   }
15240   {
15241     try {
15242       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15243     } catch (std::out_of_range& e) {
15244       {
15245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15246       };
15247     } catch (std::exception& e) {
15248       {
15249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15250       };
15251     } catch (...) {
15252       {
15253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15254       };
15255     }
15256   }
15257   jresult = (void *)result;
15258   return jresult;
15259 }
15260
15261
15262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15263   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15264
15265   arg1 = (Dali::Property::Value *)jarg1;
15266   {
15267     try {
15268       delete arg1;
15269     } catch (std::out_of_range& e) {
15270       {
15271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15272       };
15273     } catch (std::exception& e) {
15274       {
15275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15276       };
15277     } catch (...) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15280       };
15281     }
15282   }
15283 }
15284
15285
15286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15287   int jresult ;
15288   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15289   Dali::Property::Type result;
15290
15291   arg1 = (Dali::Property::Value *)jarg1;
15292   {
15293     try {
15294       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15295     } catch (std::out_of_range& e) {
15296       {
15297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15298       };
15299     } catch (std::exception& e) {
15300       {
15301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (...) {
15304       {
15305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15306       };
15307     }
15308   }
15309   jresult = (int)result;
15310   return jresult;
15311 }
15312
15313
15314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15315   unsigned int jresult ;
15316   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15317   bool *arg2 = 0 ;
15318   bool result;
15319
15320   arg1 = (Dali::Property::Value *)jarg1;
15321   arg2 = (bool *)jarg2;
15322   {
15323     try {
15324       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15325     } catch (std::out_of_range& e) {
15326       {
15327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15328       };
15329     } catch (std::exception& e) {
15330       {
15331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15332       };
15333     } catch (...) {
15334       {
15335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15336       };
15337     }
15338   }
15339   jresult = result;
15340   return jresult;
15341 }
15342
15343
15344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15345   unsigned int jresult ;
15346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15347   float *arg2 = 0 ;
15348   bool result;
15349
15350   arg1 = (Dali::Property::Value *)jarg1;
15351   arg2 = (float *)jarg2;
15352   {
15353     try {
15354       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15355     } catch (std::out_of_range& e) {
15356       {
15357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15358       };
15359     } catch (std::exception& e) {
15360       {
15361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15362       };
15363     } catch (...) {
15364       {
15365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15366       };
15367     }
15368   }
15369   jresult = result;
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15375   unsigned int jresult ;
15376   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15377   int *arg2 = 0 ;
15378   bool result;
15379
15380   arg1 = (Dali::Property::Value *)jarg1;
15381   arg2 = (int *)jarg2;
15382   {
15383     try {
15384       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15385     } catch (std::out_of_range& e) {
15386       {
15387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15388       };
15389     } catch (std::exception& e) {
15390       {
15391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15392       };
15393     } catch (...) {
15394       {
15395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15396       };
15397     }
15398   }
15399   jresult = result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15405   unsigned int jresult ;
15406   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15407   Dali::Rect< int > *arg2 = 0 ;
15408   bool result;
15409
15410   arg1 = (Dali::Property::Value *)jarg1;
15411   arg2 = (Dali::Rect< int > *)jarg2;
15412   if (!arg2) {
15413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15414     return 0;
15415   }
15416   {
15417     try {
15418       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15419     } catch (std::out_of_range& e) {
15420       {
15421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15422       };
15423     } catch (std::exception& e) {
15424       {
15425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15426       };
15427     } catch (...) {
15428       {
15429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15430       };
15431     }
15432   }
15433   jresult = result;
15434   return jresult;
15435 }
15436
15437
15438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15439   unsigned int jresult ;
15440   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15441   Dali::Vector2 *arg2 = 0 ;
15442   bool result;
15443
15444   arg1 = (Dali::Property::Value *)jarg1;
15445   arg2 = (Dali::Vector2 *)jarg2;
15446   if (!arg2) {
15447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15448     return 0;
15449   }
15450   {
15451     try {
15452       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15453     } catch (std::out_of_range& e) {
15454       {
15455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15456       };
15457     } catch (std::exception& e) {
15458       {
15459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15460       };
15461     } catch (...) {
15462       {
15463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15464       };
15465     }
15466   }
15467   jresult = result;
15468   return jresult;
15469 }
15470
15471
15472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15473   unsigned int jresult ;
15474   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15475   Dali::Vector3 *arg2 = 0 ;
15476   bool result;
15477
15478   arg1 = (Dali::Property::Value *)jarg1;
15479   arg2 = (Dali::Vector3 *)jarg2;
15480   if (!arg2) {
15481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15482     return 0;
15483   }
15484   {
15485     try {
15486       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15487     } catch (std::out_of_range& e) {
15488       {
15489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (std::exception& e) {
15492       {
15493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (...) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15498       };
15499     }
15500   }
15501   jresult = result;
15502   return jresult;
15503 }
15504
15505
15506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15507   unsigned int jresult ;
15508   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15509   Dali::Vector4 *arg2 = 0 ;
15510   bool result;
15511
15512   arg1 = (Dali::Property::Value *)jarg1;
15513   arg2 = (Dali::Vector4 *)jarg2;
15514   if (!arg2) {
15515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15516     return 0;
15517   }
15518   {
15519     try {
15520       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15521     } catch (std::out_of_range& e) {
15522       {
15523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (std::exception& e) {
15526       {
15527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15528       };
15529     } catch (...) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15532       };
15533     }
15534   }
15535   jresult = result;
15536   return jresult;
15537 }
15538
15539
15540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15541   unsigned int jresult ;
15542   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15543   Dali::Matrix3 *arg2 = 0 ;
15544   bool result;
15545
15546   arg1 = (Dali::Property::Value *)jarg1;
15547   arg2 = (Dali::Matrix3 *)jarg2;
15548   if (!arg2) {
15549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15550     return 0;
15551   }
15552   {
15553     try {
15554       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15555     } catch (std::out_of_range& e) {
15556       {
15557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15558       };
15559     } catch (std::exception& e) {
15560       {
15561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15562       };
15563     } catch (...) {
15564       {
15565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15566       };
15567     }
15568   }
15569   jresult = result;
15570   return jresult;
15571 }
15572
15573
15574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15575   unsigned int jresult ;
15576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15577   Dali::Matrix *arg2 = 0 ;
15578   bool result;
15579
15580   arg1 = (Dali::Property::Value *)jarg1;
15581   arg2 = (Dali::Matrix *)jarg2;
15582   if (!arg2) {
15583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15584     return 0;
15585   }
15586   {
15587     try {
15588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15589     } catch (std::out_of_range& e) {
15590       {
15591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15592       };
15593     } catch (std::exception& e) {
15594       {
15595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15596       };
15597     } catch (...) {
15598       {
15599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15600       };
15601     }
15602   }
15603   jresult = result;
15604   return jresult;
15605 }
15606
15607
15608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15609   unsigned int jresult ;
15610   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15611   Dali::AngleAxis *arg2 = 0 ;
15612   bool result;
15613
15614   arg1 = (Dali::Property::Value *)jarg1;
15615   arg2 = (Dali::AngleAxis *)jarg2;
15616   if (!arg2) {
15617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15618     return 0;
15619   }
15620   {
15621     try {
15622       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15623     } catch (std::out_of_range& e) {
15624       {
15625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15626       };
15627     } catch (std::exception& e) {
15628       {
15629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15630       };
15631     } catch (...) {
15632       {
15633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15634       };
15635     }
15636   }
15637   jresult = result;
15638   return jresult;
15639 }
15640
15641
15642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15643   unsigned int jresult ;
15644   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15645   Dali::Quaternion *arg2 = 0 ;
15646   bool result;
15647
15648   arg1 = (Dali::Property::Value *)jarg1;
15649   arg2 = (Dali::Quaternion *)jarg2;
15650   if (!arg2) {
15651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15652     return 0;
15653   }
15654   {
15655     try {
15656       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15657     } catch (std::out_of_range& e) {
15658       {
15659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15660       };
15661     } catch (std::exception& e) {
15662       {
15663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15664       };
15665     } catch (...) {
15666       {
15667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15668       };
15669     }
15670   }
15671   jresult = result;
15672   return jresult;
15673 }
15674
15675
15676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15677   unsigned int jresult ;
15678   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15679   std::string *arg2 = 0 ;
15680   bool result;
15681
15682   arg1 = (Dali::Property::Value *)jarg1;
15683
15684   //typemap in
15685   std::string temp;
15686   arg2 = &temp;
15687
15688   {
15689     try {
15690       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15691     } catch (std::out_of_range& e) {
15692       {
15693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15694       };
15695     } catch (std::exception& e) {
15696       {
15697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15698       };
15699     } catch (...) {
15700       {
15701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15702       };
15703     }
15704   }
15705   jresult = result;
15706
15707   //Typemap argout in c++ file.
15708   //This will convert c++ string to c# string
15709   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15710
15711   return jresult;
15712 }
15713
15714
15715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15716   unsigned int jresult ;
15717   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15718   Dali::Property::Array *arg2 = 0 ;
15719   bool result;
15720
15721   arg1 = (Dali::Property::Value *)jarg1;
15722   arg2 = (Dali::Property::Array *)jarg2;
15723   if (!arg2) {
15724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15725     return 0;
15726   }
15727   {
15728     try {
15729       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15730     } catch (std::out_of_range& e) {
15731       {
15732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15733       };
15734     } catch (std::exception& e) {
15735       {
15736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15737       };
15738     } catch (...) {
15739       {
15740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15741       };
15742     }
15743   }
15744   jresult = result;
15745   return jresult;
15746 }
15747
15748
15749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15750   unsigned int jresult ;
15751   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15752   Dali::Property::Map *arg2 = 0 ;
15753   bool result;
15754
15755   arg1 = (Dali::Property::Value *)jarg1;
15756   arg2 = (Dali::Property::Map *)jarg2;
15757   if (!arg2) {
15758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15759     return 0;
15760   }
15761   {
15762     try {
15763       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15764     } catch (std::out_of_range& e) {
15765       {
15766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15767       };
15768     } catch (std::exception& e) {
15769       {
15770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15771       };
15772     } catch (...) {
15773       {
15774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15775       };
15776     }
15777   }
15778   jresult = result;
15779   return jresult;
15780 }
15781
15782
15783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15784   void * jresult ;
15785   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15786   Dali::Property::Array *result = 0 ;
15787
15788   arg1 = (Dali::Property::Value *)jarg1;
15789   {
15790     try {
15791       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15792     } catch (std::out_of_range& e) {
15793       {
15794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15795       };
15796     } catch (std::exception& e) {
15797       {
15798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15799       };
15800     } catch (...) {
15801       {
15802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15803       };
15804     }
15805   }
15806   jresult = (void *)result;
15807   return jresult;
15808 }
15809
15810
15811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15812   void * jresult ;
15813   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15814   Dali::Property::Map *result = 0 ;
15815
15816   arg1 = (Dali::Property::Value *)jarg1;
15817   {
15818     try {
15819       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15820     } catch (std::out_of_range& e) {
15821       {
15822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15823       };
15824     } catch (std::exception& e) {
15825       {
15826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15827       };
15828     } catch (...) {
15829       {
15830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15831       };
15832     }
15833   }
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15840   char * jresult ;
15841   Dali::Property::Type arg1 ;
15842   char *result = 0 ;
15843
15844   arg1 = (Dali::Property::Type)jarg1;
15845   {
15846     try {
15847       result = (char *)Dali::PropertyTypes::GetName(arg1);
15848     } catch (std::out_of_range& e) {
15849       {
15850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15851       };
15852     } catch (std::exception& e) {
15853       {
15854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (...) {
15857       {
15858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15859       };
15860     }
15861   }
15862   jresult = SWIG_csharp_string_callback((const char *)result);
15863   return jresult;
15864 }
15865
15866
15867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15868   unsigned int jresult ;
15869   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15870   std::string *arg2 = 0 ;
15871   Dali::Property::Map *arg3 = 0 ;
15872   bool result;
15873
15874   arg1 = (Dali::BaseObject *)jarg1;
15875   if (!jarg2) {
15876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15877     return 0;
15878   }
15879   std::string arg2_str(jarg2);
15880   arg2 = &arg2_str;
15881   arg3 = (Dali::Property::Map *)jarg3;
15882   if (!arg3) {
15883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15884     return 0;
15885   }
15886   {
15887     try {
15888       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15889     } catch (std::out_of_range& e) {
15890       {
15891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15892       };
15893     } catch (std::exception& e) {
15894       {
15895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15900       };
15901     }
15902   }
15903   jresult = result;
15904
15905   //argout typemap for const std::string&
15906
15907   return jresult;
15908 }
15909
15910
15911 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15912   char * jresult ;
15913   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15914   std::string *result = 0 ;
15915
15916   arg1 = (Dali::BaseObject *)jarg1;
15917   {
15918     try {
15919       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15920     } catch (std::out_of_range& e) {
15921       {
15922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (std::exception& e) {
15925       {
15926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934   jresult = SWIG_csharp_string_callback(result->c_str());
15935   return jresult;
15936 }
15937
15938
15939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15940   unsigned int jresult ;
15941   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15942   Dali::TypeInfo *arg2 = 0 ;
15943   bool result;
15944
15945   arg1 = (Dali::BaseObject *)jarg1;
15946   arg2 = (Dali::TypeInfo *)jarg2;
15947   if (!arg2) {
15948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15949     return 0;
15950   }
15951   {
15952     try {
15953       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15954     } catch (std::out_of_range& e) {
15955       {
15956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15957       };
15958     } catch (std::exception& e) {
15959       {
15960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15961       };
15962     } catch (...) {
15963       {
15964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15965       };
15966     }
15967   }
15968   jresult = result;
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15974   unsigned int jresult ;
15975   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15976   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15977   std::string *arg3 = 0 ;
15978   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15979   bool result;
15980
15981   arg1 = (Dali::BaseObject *)jarg1;
15982   arg2 = (ConnectionTrackerInterface *)jarg2;
15983   if (!jarg3) {
15984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15985     return 0;
15986   }
15987   std::string arg3_str(jarg3);
15988   arg3 = &arg3_str;
15989   arg4 = (FunctorDelegate *)jarg4;
15990   {
15991     try {
15992       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15993     } catch (std::out_of_range& e) {
15994       {
15995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15996       };
15997     } catch (std::exception& e) {
15998       {
15999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16000       };
16001     } catch (...) {
16002       {
16003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16004       };
16005     }
16006   }
16007   jresult = result;
16008
16009   //argout typemap for const std::string&
16010
16011   return jresult;
16012 }
16013
16014
16015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16016   void * jresult ;
16017   Dali::BaseHandle *arg1 = 0 ;
16018   Dali::BaseObject *result = 0 ;
16019
16020   arg1 = (Dali::BaseHandle *)jarg1;
16021   if (!arg1) {
16022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16023     return 0;
16024   }
16025   {
16026     try {
16027       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16028     } catch (std::out_of_range& e) {
16029       {
16030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16031       };
16032     } catch (std::exception& e) {
16033       {
16034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16035       };
16036     } catch (...) {
16037       {
16038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16039       };
16040     }
16041   }
16042   jresult = (void *)result;
16043   return jresult;
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16048   void * jresult ;
16049   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16050   Dali::BaseHandle *result = 0 ;
16051
16052   arg1 = (Dali::BaseObject *)jarg1;
16053   {
16054     try {
16055       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (...) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16067       };
16068     }
16069   }
16070   jresult = (void *)result;
16071   return jresult;
16072 }
16073
16074
16075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16076   void * jresult ;
16077   Dali::BaseHandle *result = 0 ;
16078
16079   {
16080     try {
16081       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16082     } catch (std::out_of_range& e) {
16083       {
16084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16085       };
16086     } catch (std::exception& e) {
16087       {
16088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16089       };
16090     } catch (...) {
16091       {
16092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16093       };
16094     }
16095   }
16096   jresult = (void *)result;
16097   return jresult;
16098 }
16099
16100
16101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16102   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16103
16104   arg1 = (Dali::BaseHandle *)jarg1;
16105   {
16106     try {
16107       delete arg1;
16108     } catch (std::out_of_range& e) {
16109       {
16110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16111       };
16112     } catch (std::exception& e) {
16113       {
16114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16115       };
16116     } catch (...) {
16117       {
16118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16119       };
16120     }
16121   }
16122 }
16123
16124
16125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16126   void * jresult ;
16127   Dali::BaseHandle *arg1 = 0 ;
16128   Dali::BaseHandle *result = 0 ;
16129
16130   arg1 = (Dali::BaseHandle *)jarg1;
16131   if (!arg1) {
16132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16133     return 0;
16134   }
16135   {
16136     try {
16137       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (...) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16149       };
16150     }
16151   }
16152   jresult = (void *)result;
16153   return jresult;
16154 }
16155
16156
16157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16158   void * jresult ;
16159   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16160   Dali::BaseHandle *arg2 = 0 ;
16161   Dali::BaseHandle *result = 0 ;
16162
16163   arg1 = (Dali::BaseHandle *)jarg1;
16164   arg2 = (Dali::BaseHandle *)jarg2;
16165   if (!arg2) {
16166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16167     return 0;
16168   }
16169   {
16170     try {
16171       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16172     } catch (std::out_of_range& e) {
16173       {
16174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16175       };
16176     } catch (std::exception& e) {
16177       {
16178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (...) {
16181       {
16182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16183       };
16184     }
16185   }
16186   jresult = (void *)result;
16187   return jresult;
16188 }
16189
16190
16191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16192   unsigned int jresult ;
16193   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16194   std::string *arg2 = 0 ;
16195   Dali::Property::Map *arg3 = 0 ;
16196   bool result;
16197
16198   arg1 = (Dali::BaseHandle *)jarg1;
16199   if (!jarg2) {
16200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16201     return 0;
16202   }
16203   std::string arg2_str(jarg2);
16204   arg2 = &arg2_str;
16205   arg3 = (Dali::Property::Map *)jarg3;
16206   if (!arg3) {
16207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16208     return 0;
16209   }
16210   {
16211     try {
16212       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16213     } catch (std::out_of_range& e) {
16214       {
16215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16216       };
16217     } catch (std::exception& e) {
16218       {
16219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16220       };
16221     } catch (...) {
16222       {
16223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16224       };
16225     }
16226   }
16227   jresult = result;
16228
16229   //argout typemap for const std::string&
16230
16231   return jresult;
16232 }
16233
16234
16235 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16236   char * jresult ;
16237   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16238   std::string *result = 0 ;
16239
16240   arg1 = (Dali::BaseHandle *)jarg1;
16241   {
16242     try {
16243       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16244     } catch (std::out_of_range& e) {
16245       {
16246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16247       };
16248     } catch (std::exception& e) {
16249       {
16250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16251       };
16252     } catch (...) {
16253       {
16254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16255       };
16256     }
16257   }
16258   jresult = SWIG_csharp_string_callback(result->c_str());
16259   return jresult;
16260 }
16261
16262
16263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16264   unsigned int jresult ;
16265   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16266   Dali::TypeInfo *arg2 = 0 ;
16267   bool result;
16268
16269   arg1 = (Dali::BaseHandle *)jarg1;
16270   arg2 = (Dali::TypeInfo *)jarg2;
16271   if (!arg2) {
16272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16273     return 0;
16274   }
16275   {
16276     try {
16277       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16278     } catch (std::out_of_range& e) {
16279       {
16280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (std::exception& e) {
16283       {
16284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (...) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16289       };
16290     }
16291   }
16292   jresult = result;
16293   return jresult;
16294 }
16295
16296
16297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16298   void * jresult ;
16299   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16300   Dali::BaseObject *result = 0 ;
16301
16302   arg1 = (Dali::BaseHandle *)jarg1;
16303   {
16304     try {
16305       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16306     } catch (std::out_of_range& e) {
16307       {
16308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16309       };
16310     } catch (std::exception& e) {
16311       {
16312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16313       };
16314     } catch (...) {
16315       {
16316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16317       };
16318     }
16319   }
16320   jresult = (void *)result;
16321   return jresult;
16322 }
16323
16324
16325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16326   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16327
16328   arg1 = (Dali::BaseHandle *)jarg1;
16329   {
16330     try {
16331       (arg1)->Reset();
16332     } catch (std::out_of_range& e) {
16333       {
16334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16335       };
16336     } catch (std::exception& e) {
16337       {
16338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16339       };
16340     } catch (...) {
16341       {
16342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16343       };
16344     }
16345   }
16346 }
16347
16348
16349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16350   unsigned int jresult ;
16351   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16352   Dali::BaseHandle *arg2 = 0 ;
16353   bool result;
16354
16355   arg1 = (Dali::BaseHandle *)jarg1;
16356   arg2 = (Dali::BaseHandle *)jarg2;
16357   if (!arg2) {
16358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16359     return 0;
16360   }
16361   {
16362     try {
16363       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16364     } catch (std::out_of_range& e) {
16365       {
16366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16367       };
16368     } catch (std::exception& e) {
16369       {
16370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16371       };
16372     } catch (...) {
16373       {
16374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16375       };
16376     }
16377   }
16378   jresult = result;
16379   return jresult;
16380 }
16381
16382
16383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16384   unsigned int jresult ;
16385   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16386   Dali::BaseHandle *arg2 = 0 ;
16387   bool result;
16388
16389   arg1 = (Dali::BaseHandle *)jarg1;
16390   arg2 = (Dali::BaseHandle *)jarg2;
16391   if (!arg2) {
16392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16393     return 0;
16394   }
16395   {
16396     try {
16397       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16398     } catch (std::out_of_range& e) {
16399       {
16400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (std::exception& e) {
16403       {
16404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (...) {
16407       {
16408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16409       };
16410     }
16411   }
16412   jresult = result;
16413   return jresult;
16414 }
16415
16416
16417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16418   void * jresult ;
16419   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16420   Dali::RefObject *result = 0 ;
16421
16422   arg1 = (Dali::BaseHandle *)jarg1;
16423   {
16424     try {
16425       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16426     } catch (std::out_of_range& e) {
16427       {
16428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16429       };
16430     } catch (std::exception& e) {
16431       {
16432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16433       };
16434     } catch (...) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16437       };
16438     }
16439   }
16440   jresult = (void *)result;
16441   return jresult;
16442 }
16443
16444
16445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16446   unsigned int jresult ;
16447   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16448   bool result;
16449
16450   arg1 = (Dali::BaseHandle *)jarg1;
16451   {
16452     try {
16453       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16454     } catch (std::out_of_range& e) {
16455       {
16456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16457       };
16458     } catch (std::exception& e) {
16459       {
16460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16461       };
16462     } catch (...) {
16463       {
16464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16465       };
16466     }
16467   }
16468   jresult = result;
16469   return jresult;
16470 }
16471
16472
16473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16474   unsigned int jresult ;
16475   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16476   Dali::BaseHandle *arg2 = 0 ;
16477   bool result;
16478
16479   arg1 = (Dali::BaseHandle *)jarg1;
16480   arg2 = (Dali::BaseHandle *)jarg2;
16481   if (!arg2) {
16482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16483     return 0;
16484   }
16485   {
16486     try {
16487       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16488     } catch (std::out_of_range& e) {
16489       {
16490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16491       };
16492     } catch (std::exception& e) {
16493       {
16494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16495       };
16496     } catch (...) {
16497       {
16498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16499       };
16500     }
16501   }
16502   jresult = result;
16503   return jresult;
16504 }
16505
16506
16507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16508   unsigned int jresult ;
16509   Dali::BaseHandle *arg1 = 0 ;
16510   Dali::BaseHandle *arg2 = 0 ;
16511   bool result;
16512
16513   arg1 = (Dali::BaseHandle *)jarg1;
16514   if (!arg1) {
16515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16516     return 0;
16517   }
16518   arg2 = (Dali::BaseHandle *)jarg2;
16519   if (!arg2) {
16520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16521     return 0;
16522   }
16523   {
16524     try {
16525       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16526     } catch (std::out_of_range& e) {
16527       {
16528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16529       };
16530     } catch (std::exception& e) {
16531       {
16532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16533       };
16534     } catch (...) {
16535       {
16536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16537       };
16538     }
16539   }
16540   jresult = result;
16541   return jresult;
16542 }
16543
16544
16545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16546   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16547
16548   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16549   {
16550     try {
16551       delete arg1;
16552     } catch (std::out_of_range& e) {
16553       {
16554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16555       };
16556     } catch (std::exception& e) {
16557       {
16558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16559       };
16560     } catch (...) {
16561       {
16562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16563       };
16564     }
16565   }
16566 }
16567
16568
16569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16570   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16571   SlotObserver *arg2 = (SlotObserver *) 0 ;
16572   CallbackBase *arg3 = (CallbackBase *) 0 ;
16573
16574   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16575   arg2 = (SlotObserver *)jarg2;
16576   arg3 = (CallbackBase *)jarg3;
16577   {
16578     try {
16579       (arg1)->SignalConnected(arg2,arg3);
16580     } catch (std::out_of_range& e) {
16581       {
16582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16583       };
16584     } catch (std::exception& e) {
16585       {
16586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16591       };
16592     }
16593   }
16594 }
16595
16596
16597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16598   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16599
16600   arg1 = (Dali::SignalObserver *)jarg1;
16601   {
16602     try {
16603       delete arg1;
16604     } catch (std::out_of_range& e) {
16605       {
16606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16607       };
16608     } catch (std::exception& e) {
16609       {
16610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16611       };
16612     } catch (...) {
16613       {
16614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16615       };
16616     }
16617   }
16618 }
16619
16620
16621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16622   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16623   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16624   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16625
16626   arg1 = (Dali::SignalObserver *)jarg1;
16627   arg2 = (Dali::SlotObserver *)jarg2;
16628   arg3 = (Dali::CallbackBase *)jarg3;
16629   {
16630     try {
16631       (arg1)->SignalDisconnected(arg2,arg3);
16632     } catch (std::out_of_range& e) {
16633       {
16634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16635       };
16636     } catch (std::exception& e) {
16637       {
16638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16639       };
16640     } catch (...) {
16641       {
16642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16643       };
16644     }
16645   }
16646 }
16647
16648
16649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16650   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16651
16652   arg1 = (Dali::SlotObserver *)jarg1;
16653   {
16654     try {
16655       delete arg1;
16656     } catch (std::out_of_range& e) {
16657       {
16658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16659       };
16660     } catch (std::exception& e) {
16661       {
16662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16663       };
16664     } catch (...) {
16665       {
16666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16667       };
16668     }
16669   }
16670 }
16671
16672
16673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16674   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16675   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16676
16677   arg1 = (Dali::SlotObserver *)jarg1;
16678   arg2 = (Dali::CallbackBase *)jarg2;
16679   {
16680     try {
16681       (arg1)->SlotDisconnected(arg2);
16682     } catch (std::out_of_range& e) {
16683       {
16684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16685       };
16686     } catch (std::exception& e) {
16687       {
16688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16689       };
16690     } catch (...) {
16691       {
16692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16693       };
16694     }
16695   }
16696 }
16697
16698
16699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16700   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16701
16702   arg1 = (Dali::ConnectionTracker *)jarg1;
16703   {
16704     try {
16705       delete arg1;
16706     } catch (std::out_of_range& e) {
16707       {
16708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16709       };
16710     } catch (std::exception& e) {
16711       {
16712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16713       };
16714     } catch (...) {
16715       {
16716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16717       };
16718     }
16719   }
16720 }
16721
16722
16723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16724   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16725
16726   arg1 = (Dali::ConnectionTracker *)jarg1;
16727   {
16728     try {
16729       (arg1)->DisconnectAll();
16730     } catch (std::out_of_range& e) {
16731       {
16732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16733       };
16734     } catch (std::exception& e) {
16735       {
16736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16737       };
16738     } catch (...) {
16739       {
16740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16741       };
16742     }
16743   }
16744 }
16745
16746
16747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16748   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16749   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16750   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16751
16752   arg1 = (Dali::ConnectionTracker *)jarg1;
16753   arg2 = (Dali::SlotObserver *)jarg2;
16754   arg3 = (Dali::CallbackBase *)jarg3;
16755   {
16756     try {
16757       (arg1)->SignalConnected(arg2,arg3);
16758     } catch (std::out_of_range& e) {
16759       {
16760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16761       };
16762     } catch (std::exception& e) {
16763       {
16764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16765       };
16766     } catch (...) {
16767       {
16768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16769       };
16770     }
16771   }
16772 }
16773
16774
16775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16776   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16777   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16778   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16779
16780   arg1 = (Dali::ConnectionTracker *)jarg1;
16781   arg2 = (Dali::SlotObserver *)jarg2;
16782   arg3 = (Dali::CallbackBase *)jarg3;
16783   {
16784     try {
16785       (arg1)->SignalDisconnected(arg2,arg3);
16786     } catch (std::out_of_range& e) {
16787       {
16788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16789       };
16790     } catch (std::exception& e) {
16791       {
16792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16793       };
16794     } catch (...) {
16795       {
16796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16797       };
16798     }
16799   }
16800 }
16801
16802
16803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16804   unsigned long jresult ;
16805   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16806   std::size_t result;
16807
16808   arg1 = (Dali::ConnectionTracker *)jarg1;
16809   {
16810     try {
16811       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16812     } catch (std::out_of_range& e) {
16813       {
16814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16815       };
16816     } catch (std::exception& e) {
16817       {
16818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16819       };
16820     } catch (...) {
16821       {
16822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16823       };
16824     }
16825   }
16826   jresult = (unsigned long)result;
16827   return jresult;
16828 }
16829
16830
16831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16832   void * jresult ;
16833   Dali::ObjectRegistry *result = 0 ;
16834
16835   {
16836     try {
16837       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16838     } catch (std::out_of_range& e) {
16839       {
16840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16841       };
16842     } catch (std::exception& e) {
16843       {
16844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16845       };
16846     } catch (...) {
16847       {
16848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16849       };
16850     }
16851   }
16852   jresult = (void *)result;
16853   return jresult;
16854 }
16855
16856
16857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16858   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16859
16860   arg1 = (Dali::ObjectRegistry *)jarg1;
16861   {
16862     try {
16863       delete arg1;
16864     } catch (std::out_of_range& e) {
16865       {
16866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16867       };
16868     } catch (std::exception& e) {
16869       {
16870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16871       };
16872     } catch (...) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16875       };
16876     }
16877   }
16878 }
16879
16880
16881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16882   void * jresult ;
16883   Dali::ObjectRegistry *arg1 = 0 ;
16884   Dali::ObjectRegistry *result = 0 ;
16885
16886   arg1 = (Dali::ObjectRegistry *)jarg1;
16887   if (!arg1) {
16888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16889     return 0;
16890   }
16891   {
16892     try {
16893       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16894     } catch (std::out_of_range& e) {
16895       {
16896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16897       };
16898     } catch (std::exception& e) {
16899       {
16900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (...) {
16903       {
16904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16905       };
16906     }
16907   }
16908   jresult = (void *)result;
16909   return jresult;
16910 }
16911
16912
16913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16914   void * jresult ;
16915   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16916   Dali::ObjectRegistry *arg2 = 0 ;
16917   Dali::ObjectRegistry *result = 0 ;
16918
16919   arg1 = (Dali::ObjectRegistry *)jarg1;
16920   arg2 = (Dali::ObjectRegistry *)jarg2;
16921   if (!arg2) {
16922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16923     return 0;
16924   }
16925   {
16926     try {
16927       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16928     } catch (std::out_of_range& e) {
16929       {
16930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16931       };
16932     } catch (std::exception& e) {
16933       {
16934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16935       };
16936     } catch (...) {
16937       {
16938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16939       };
16940     }
16941   }
16942   jresult = (void *)result;
16943   return jresult;
16944 }
16945
16946
16947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16948   void * jresult ;
16949   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16950   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16951
16952   arg1 = (Dali::ObjectRegistry *)jarg1;
16953   {
16954     try {
16955       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16956     } catch (std::out_of_range& e) {
16957       {
16958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16959       };
16960     } catch (std::exception& e) {
16961       {
16962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16963       };
16964     } catch (...) {
16965       {
16966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16967       };
16968     }
16969   }
16970   jresult = (void *)result;
16971   return jresult;
16972 }
16973
16974
16975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16976   void * jresult ;
16977   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16978   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16979
16980   arg1 = (Dali::ObjectRegistry *)jarg1;
16981   {
16982     try {
16983       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16984     } catch (std::out_of_range& e) {
16985       {
16986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16987       };
16988     } catch (std::exception& e) {
16989       {
16990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16991       };
16992     } catch (...) {
16993       {
16994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16995       };
16996     }
16997   }
16998   jresult = (void *)result;
16999   return jresult;
17000 }
17001
17002
17003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17004   void * jresult ;
17005   Dali::PropertyCondition *result = 0 ;
17006
17007   {
17008     try {
17009       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (...) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17021       };
17022     }
17023   }
17024   jresult = (void *)result;
17025   return jresult;
17026 }
17027
17028
17029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17030   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17031
17032   arg1 = (Dali::PropertyCondition *)jarg1;
17033   {
17034     try {
17035       delete arg1;
17036     } catch (std::out_of_range& e) {
17037       {
17038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17039       };
17040     } catch (std::exception& e) {
17041       {
17042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17043       };
17044     } catch (...) {
17045       {
17046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17047       };
17048     }
17049   }
17050 }
17051
17052
17053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17054   void * jresult ;
17055   Dali::PropertyCondition *arg1 = 0 ;
17056   Dali::PropertyCondition *result = 0 ;
17057
17058   arg1 = (Dali::PropertyCondition *)jarg1;
17059   if (!arg1) {
17060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17061     return 0;
17062   }
17063   {
17064     try {
17065       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17066     } catch (std::out_of_range& e) {
17067       {
17068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17069       };
17070     } catch (std::exception& e) {
17071       {
17072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (...) {
17075       {
17076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17077       };
17078     }
17079   }
17080   jresult = (void *)result;
17081   return jresult;
17082 }
17083
17084
17085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17086   void * jresult ;
17087   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17088   Dali::PropertyCondition *arg2 = 0 ;
17089   Dali::PropertyCondition *result = 0 ;
17090
17091   arg1 = (Dali::PropertyCondition *)jarg1;
17092   arg2 = (Dali::PropertyCondition *)jarg2;
17093   if (!arg2) {
17094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17095     return 0;
17096   }
17097   {
17098     try {
17099       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17100     } catch (std::out_of_range& e) {
17101       {
17102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17103       };
17104     } catch (std::exception& e) {
17105       {
17106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17107       };
17108     } catch (...) {
17109       {
17110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17111       };
17112     }
17113   }
17114   jresult = (void *)result;
17115   return jresult;
17116 }
17117
17118
17119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17120   unsigned long jresult ;
17121   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17122   std::size_t result;
17123
17124   arg1 = (Dali::PropertyCondition *)jarg1;
17125   {
17126     try {
17127       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17128     } catch (std::out_of_range& e) {
17129       {
17130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17131       };
17132     } catch (std::exception& e) {
17133       {
17134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17135       };
17136     } catch (...) {
17137       {
17138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17139       };
17140     }
17141   }
17142   jresult = (unsigned long)result;
17143   return jresult;
17144 }
17145
17146
17147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17148   float jresult ;
17149   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17150   std::size_t arg2 ;
17151   float result;
17152
17153   arg1 = (Dali::PropertyCondition *)jarg1;
17154   arg2 = (std::size_t)jarg2;
17155   {
17156     try {
17157       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17158     } catch (std::out_of_range& e) {
17159       {
17160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17161       };
17162     } catch (std::exception& e) {
17163       {
17164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (...) {
17167       {
17168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17169       };
17170     }
17171   }
17172   jresult = result;
17173   return jresult;
17174 }
17175
17176
17177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17178   void * jresult ;
17179   float arg1 ;
17180   Dali::PropertyCondition result;
17181
17182   arg1 = (float)jarg1;
17183   {
17184     try {
17185       result = Dali::LessThanCondition(arg1);
17186     } catch (std::out_of_range& e) {
17187       {
17188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (std::exception& e) {
17191       {
17192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17193       };
17194     } catch (...) {
17195       {
17196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17197       };
17198     }
17199   }
17200   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17201   return jresult;
17202 }
17203
17204
17205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17206   void * jresult ;
17207   float arg1 ;
17208   Dali::PropertyCondition result;
17209
17210   arg1 = (float)jarg1;
17211   {
17212     try {
17213       result = Dali::GreaterThanCondition(arg1);
17214     } catch (std::out_of_range& e) {
17215       {
17216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17217       };
17218     } catch (std::exception& e) {
17219       {
17220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17221       };
17222     } catch (...) {
17223       {
17224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17225       };
17226     }
17227   }
17228   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17229   return jresult;
17230 }
17231
17232
17233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17234   void * jresult ;
17235   float arg1 ;
17236   float arg2 ;
17237   Dali::PropertyCondition result;
17238
17239   arg1 = (float)jarg1;
17240   arg2 = (float)jarg2;
17241   {
17242     try {
17243       result = Dali::InsideCondition(arg1,arg2);
17244     } catch (std::out_of_range& e) {
17245       {
17246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17247       };
17248     } catch (std::exception& e) {
17249       {
17250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17251       };
17252     } catch (...) {
17253       {
17254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17255       };
17256     }
17257   }
17258   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17259   return jresult;
17260 }
17261
17262
17263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17264   void * jresult ;
17265   float arg1 ;
17266   float arg2 ;
17267   Dali::PropertyCondition result;
17268
17269   arg1 = (float)jarg1;
17270   arg2 = (float)jarg2;
17271   {
17272     try {
17273       result = Dali::OutsideCondition(arg1,arg2);
17274     } catch (std::out_of_range& e) {
17275       {
17276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17277       };
17278     } catch (std::exception& e) {
17279       {
17280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17281       };
17282     } catch (...) {
17283       {
17284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17285       };
17286     }
17287   }
17288   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17289   return jresult;
17290 }
17291
17292
17293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17294   void * jresult ;
17295   float arg1 ;
17296   float arg2 ;
17297   Dali::PropertyCondition result;
17298
17299   arg1 = (float)jarg1;
17300   arg2 = (float)jarg2;
17301   {
17302     try {
17303       result = Dali::StepCondition(arg1,arg2);
17304     } catch (std::out_of_range& e) {
17305       {
17306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (std::exception& e) {
17309       {
17310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17319   return jresult;
17320 }
17321
17322
17323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17324   void * jresult ;
17325   float arg1 ;
17326   Dali::PropertyCondition result;
17327
17328   arg1 = (float)jarg1;
17329   {
17330     try {
17331       result = Dali::StepCondition(arg1);
17332     } catch (std::out_of_range& e) {
17333       {
17334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17335       };
17336     } catch (std::exception& e) {
17337       {
17338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17339       };
17340     } catch (...) {
17341       {
17342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17343       };
17344     }
17345   }
17346   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17347   return jresult;
17348 }
17349
17350
17351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17352   void * jresult ;
17353   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17354   Dali::PropertyCondition result;
17355
17356   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17357   if (!arg1) {
17358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17359     return 0;
17360   }
17361   {
17362     try {
17363       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (...) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17375       };
17376     }
17377   }
17378   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17384   void * jresult ;
17385   Dali::PropertyNotification *result = 0 ;
17386
17387   {
17388     try {
17389       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17390     } catch (std::out_of_range& e) {
17391       {
17392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17393       };
17394     } catch (std::exception& e) {
17395       {
17396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17397       };
17398     } catch (...) {
17399       {
17400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17401       };
17402     }
17403   }
17404   jresult = (void *)result;
17405   return jresult;
17406 }
17407
17408
17409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17410   void * jresult ;
17411   Dali::BaseHandle arg1 ;
17412   Dali::BaseHandle *argp1 ;
17413   Dali::PropertyNotification result;
17414
17415   argp1 = (Dali::BaseHandle *)jarg1;
17416   if (!argp1) {
17417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17418     return 0;
17419   }
17420   arg1 = *argp1;
17421   {
17422     try {
17423       result = Dali::PropertyNotification::DownCast(arg1);
17424     } catch (std::out_of_range& e) {
17425       {
17426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17427       };
17428     } catch (std::exception& e) {
17429       {
17430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17431       };
17432     } catch (...) {
17433       {
17434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17435       };
17436     }
17437   }
17438   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17439   return jresult;
17440 }
17441
17442
17443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17444   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17445
17446   arg1 = (Dali::PropertyNotification *)jarg1;
17447   {
17448     try {
17449       delete arg1;
17450     } catch (std::out_of_range& e) {
17451       {
17452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17453       };
17454     } catch (std::exception& e) {
17455       {
17456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17457       };
17458     } catch (...) {
17459       {
17460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17461       };
17462     }
17463   }
17464 }
17465
17466
17467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17468   void * jresult ;
17469   Dali::PropertyNotification *arg1 = 0 ;
17470   Dali::PropertyNotification *result = 0 ;
17471
17472   arg1 = (Dali::PropertyNotification *)jarg1;
17473   if (!arg1) {
17474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17475     return 0;
17476   }
17477   {
17478     try {
17479       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17480     } catch (std::out_of_range& e) {
17481       {
17482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17483       };
17484     } catch (std::exception& e) {
17485       {
17486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17487       };
17488     } catch (...) {
17489       {
17490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17491       };
17492     }
17493   }
17494   jresult = (void *)result;
17495   return jresult;
17496 }
17497
17498
17499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17500   void * jresult ;
17501   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17502   Dali::PropertyNotification *arg2 = 0 ;
17503   Dali::PropertyNotification *result = 0 ;
17504
17505   arg1 = (Dali::PropertyNotification *)jarg1;
17506   arg2 = (Dali::PropertyNotification *)jarg2;
17507   if (!arg2) {
17508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17509     return 0;
17510   }
17511   {
17512     try {
17513       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17514     } catch (std::out_of_range& e) {
17515       {
17516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17517       };
17518     } catch (std::exception& e) {
17519       {
17520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17521       };
17522     } catch (...) {
17523       {
17524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17525       };
17526     }
17527   }
17528   jresult = (void *)result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17534   void * jresult ;
17535   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17536   Dali::PropertyCondition result;
17537
17538   arg1 = (Dali::PropertyNotification *)jarg1;
17539   {
17540     try {
17541       result = (arg1)->GetCondition();
17542     } catch (std::out_of_range& e) {
17543       {
17544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17545       };
17546     } catch (std::exception& e) {
17547       {
17548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17549       };
17550     } catch (...) {
17551       {
17552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17553       };
17554     }
17555   }
17556   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17557   return jresult;
17558 }
17559
17560
17561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17562   void * jresult ;
17563   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17564   Dali::Handle result;
17565
17566   arg1 = (Dali::PropertyNotification *)jarg1;
17567   {
17568     try {
17569       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17570     } catch (std::out_of_range& e) {
17571       {
17572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17573       };
17574     } catch (std::exception& e) {
17575       {
17576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17577       };
17578     } catch (...) {
17579       {
17580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17581       };
17582     }
17583   }
17584   jresult = new Dali::Handle((const Dali::Handle &)result);
17585   return jresult;
17586 }
17587
17588
17589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17590   int jresult ;
17591   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17592   Dali::Property::Index result;
17593
17594   arg1 = (Dali::PropertyNotification *)jarg1;
17595   {
17596     try {
17597       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17598     } catch (std::out_of_range& e) {
17599       {
17600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17601       };
17602     } catch (std::exception& e) {
17603       {
17604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17605       };
17606     } catch (...) {
17607       {
17608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17609       };
17610     }
17611   }
17612   jresult = result;
17613   return jresult;
17614 }
17615
17616
17617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17618   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17619   Dali::PropertyNotification::NotifyMode arg2 ;
17620
17621   arg1 = (Dali::PropertyNotification *)jarg1;
17622   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17623   {
17624     try {
17625       (arg1)->SetNotifyMode(arg2);
17626     } catch (std::out_of_range& e) {
17627       {
17628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17629       };
17630     } catch (std::exception& e) {
17631       {
17632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17633       };
17634     } catch (...) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17637       };
17638     }
17639   }
17640 }
17641
17642
17643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17644   int jresult ;
17645   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17646   Dali::PropertyNotification::NotifyMode result;
17647
17648   arg1 = (Dali::PropertyNotification *)jarg1;
17649   {
17650     try {
17651       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17652     } catch (std::out_of_range& e) {
17653       {
17654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17655       };
17656     } catch (std::exception& e) {
17657       {
17658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17659       };
17660     } catch (...) {
17661       {
17662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17663       };
17664     }
17665   }
17666   jresult = (int)result;
17667   return jresult;
17668 }
17669
17670
17671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17672   unsigned int jresult ;
17673   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17674   bool result;
17675
17676   arg1 = (Dali::PropertyNotification *)jarg1;
17677   {
17678     try {
17679       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17680     } catch (std::out_of_range& e) {
17681       {
17682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17683       };
17684     } catch (std::exception& e) {
17685       {
17686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17687       };
17688     } catch (...) {
17689       {
17690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17691       };
17692     }
17693   }
17694   jresult = result;
17695   return jresult;
17696 }
17697
17698
17699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17700   void * jresult ;
17701   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17702   Dali::PropertyNotifySignalType *result = 0 ;
17703
17704   arg1 = (Dali::PropertyNotification *)jarg1;
17705   {
17706     try {
17707       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17708     } catch (std::out_of_range& e) {
17709       {
17710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17711       };
17712     } catch (std::exception& e) {
17713       {
17714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17715       };
17716     } catch (...) {
17717       {
17718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17719       };
17720     }
17721   }
17722   jresult = (void *)result;
17723   return jresult;
17724 }
17725
17726
17727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17728   void * jresult ;
17729   Dali::Handle *result = 0 ;
17730
17731   {
17732     try {
17733       result = (Dali::Handle *)new Dali::Handle();
17734     } catch (std::out_of_range& e) {
17735       {
17736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17737       };
17738     } catch (std::exception& e) {
17739       {
17740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17741       };
17742     } catch (...) {
17743       {
17744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17745       };
17746     }
17747   }
17748   jresult = (void *)result;
17749   return jresult;
17750 }
17751
17752
17753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17754   void * jresult ;
17755   Dali::Handle result;
17756
17757   {
17758     try {
17759       result = Dali::Handle::New();
17760     } catch (std::out_of_range& e) {
17761       {
17762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17763       };
17764     } catch (std::exception& e) {
17765       {
17766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17767       };
17768     } catch (...) {
17769       {
17770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17771       };
17772     }
17773   }
17774   jresult = new Dali::Handle((const Dali::Handle &)result);
17775   return jresult;
17776 }
17777
17778
17779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17780   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17781
17782   arg1 = (Dali::Handle *)jarg1;
17783   {
17784     try {
17785       delete arg1;
17786     } catch (std::out_of_range& e) {
17787       {
17788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17789       };
17790     } catch (std::exception& e) {
17791       {
17792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17793       };
17794     } catch (...) {
17795       {
17796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17797       };
17798     }
17799   }
17800 }
17801
17802
17803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17804   void * jresult ;
17805   Dali::Handle *arg1 = 0 ;
17806   Dali::Handle *result = 0 ;
17807
17808   arg1 = (Dali::Handle *)jarg1;
17809   if (!arg1) {
17810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17811     return 0;
17812   }
17813   {
17814     try {
17815       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17816     } catch (std::out_of_range& e) {
17817       {
17818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17819       };
17820     } catch (std::exception& e) {
17821       {
17822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (...) {
17825       {
17826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17827       };
17828     }
17829   }
17830   jresult = (void *)result;
17831   return jresult;
17832 }
17833
17834
17835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17836   void * jresult ;
17837   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17838   Dali::Handle *arg2 = 0 ;
17839   Dali::Handle *result = 0 ;
17840
17841   arg1 = (Dali::Handle *)jarg1;
17842   arg2 = (Dali::Handle *)jarg2;
17843   if (!arg2) {
17844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17845     return 0;
17846   }
17847   {
17848     try {
17849       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17850     } catch (std::out_of_range& e) {
17851       {
17852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17853       };
17854     } catch (std::exception& e) {
17855       {
17856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17857       };
17858     } catch (...) {
17859       {
17860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17861       };
17862     }
17863   }
17864   jresult = (void *)result;
17865   return jresult;
17866 }
17867
17868
17869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17870   void * jresult ;
17871   Dali::BaseHandle arg1 ;
17872   Dali::BaseHandle *argp1 ;
17873   Dali::Handle result;
17874
17875   argp1 = (Dali::BaseHandle *)jarg1;
17876   if (!argp1) {
17877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17878     return 0;
17879   }
17880   arg1 = *argp1;
17881   {
17882     try {
17883       result = Dali::Handle::DownCast(arg1);
17884     } catch (std::out_of_range& e) {
17885       {
17886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17887       };
17888     } catch (std::exception& e) {
17889       {
17890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17891       };
17892     } catch (...) {
17893       {
17894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17895       };
17896     }
17897   }
17898   jresult = new Dali::Handle((const Dali::Handle &)result);
17899   return jresult;
17900 }
17901
17902
17903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17904   unsigned int jresult ;
17905   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17906   Dali::Handle::Capability arg2 ;
17907   bool result;
17908
17909   arg1 = (Dali::Handle *)jarg1;
17910   arg2 = (Dali::Handle::Capability)jarg2;
17911   {
17912     try {
17913       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17914     } catch (std::out_of_range& e) {
17915       {
17916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17917       };
17918     } catch (std::exception& e) {
17919       {
17920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17921       };
17922     } catch (...) {
17923       {
17924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17925       };
17926     }
17927   }
17928   jresult = result;
17929   return jresult;
17930 }
17931
17932
17933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17934   unsigned int jresult ;
17935   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17936   unsigned int result;
17937
17938   arg1 = (Dali::Handle *)jarg1;
17939   {
17940     try {
17941       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17942     } catch (std::out_of_range& e) {
17943       {
17944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (std::exception& e) {
17947       {
17948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17949       };
17950     } catch (...) {
17951       {
17952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17953       };
17954     }
17955   }
17956   jresult = result;
17957   return jresult;
17958 }
17959
17960
17961 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17962   char * jresult ;
17963   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17964   Dali::Property::Index arg2 ;
17965   std::string result;
17966
17967   arg1 = (Dali::Handle *)jarg1;
17968   arg2 = (Dali::Property::Index)jarg2;
17969   {
17970     try {
17971       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17972     } catch (std::out_of_range& e) {
17973       {
17974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17975       };
17976     } catch (std::exception& e) {
17977       {
17978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17979       };
17980     } catch (...) {
17981       {
17982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17983       };
17984     }
17985   }
17986   jresult = SWIG_csharp_string_callback((&result)->c_str());
17987   return jresult;
17988 }
17989
17990
17991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17992   int jresult ;
17993   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17994   std::string *arg2 = 0 ;
17995   Dali::Property::Index result;
17996
17997   arg1 = (Dali::Handle *)jarg1;
17998   if (!jarg2) {
17999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18000     return 0;
18001   }
18002   std::string arg2_str(jarg2);
18003   arg2 = &arg2_str;
18004   {
18005     try {
18006       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18007     } catch (std::out_of_range& e) {
18008       {
18009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (std::exception& e) {
18012       {
18013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18014       };
18015     } catch (...) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18018       };
18019     }
18020   }
18021   jresult = result;
18022
18023   //argout typemap for const std::string&
18024
18025   return jresult;
18026 }
18027
18028
18029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18030   unsigned int jresult ;
18031   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18032   Dali::Property::Index arg2 ;
18033   bool result;
18034
18035   arg1 = (Dali::Handle *)jarg1;
18036   arg2 = (Dali::Property::Index)jarg2;
18037   {
18038     try {
18039       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18040     } catch (std::out_of_range& e) {
18041       {
18042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (std::exception& e) {
18045       {
18046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18047       };
18048     } catch (...) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18051       };
18052     }
18053   }
18054   jresult = result;
18055   return jresult;
18056 }
18057
18058
18059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18060   unsigned int jresult ;
18061   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18062   Dali::Property::Index arg2 ;
18063   bool result;
18064
18065   arg1 = (Dali::Handle *)jarg1;
18066   arg2 = (Dali::Property::Index)jarg2;
18067   {
18068     try {
18069       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18070     } catch (std::out_of_range& e) {
18071       {
18072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18073       };
18074     } catch (std::exception& e) {
18075       {
18076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18077       };
18078     } catch (...) {
18079       {
18080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18081       };
18082     }
18083   }
18084   jresult = result;
18085   return jresult;
18086 }
18087
18088
18089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18090   unsigned int jresult ;
18091   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18092   Dali::Property::Index arg2 ;
18093   bool result;
18094
18095   arg1 = (Dali::Handle *)jarg1;
18096   arg2 = (Dali::Property::Index)jarg2;
18097   {
18098     try {
18099       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18100     } catch (std::out_of_range& e) {
18101       {
18102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18103       };
18104     } catch (std::exception& e) {
18105       {
18106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18107       };
18108     } catch (...) {
18109       {
18110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18111       };
18112     }
18113   }
18114   jresult = result;
18115   return jresult;
18116 }
18117
18118
18119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18120   int jresult ;
18121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18122   Dali::Property::Index arg2 ;
18123   Dali::Property::Type result;
18124
18125   arg1 = (Dali::Handle *)jarg1;
18126   arg2 = (Dali::Property::Index)jarg2;
18127   {
18128     try {
18129       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18130     } catch (std::out_of_range& e) {
18131       {
18132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18133       };
18134     } catch (std::exception& e) {
18135       {
18136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18137       };
18138     } catch (...) {
18139       {
18140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18141       };
18142     }
18143   }
18144   jresult = (int)result;
18145   return jresult;
18146 }
18147
18148
18149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18150   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18151   Dali::Property::Index arg2 ;
18152   Dali::Property::Value *arg3 = 0 ;
18153
18154   arg1 = (Dali::Handle *)jarg1;
18155   arg2 = (Dali::Property::Index)jarg2;
18156   arg3 = (Dali::Property::Value *)jarg3;
18157   if (!arg3) {
18158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18159     return ;
18160   }
18161   {
18162     try {
18163       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18164     } catch (std::out_of_range& e) {
18165       {
18166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18167       };
18168     } catch (std::exception& e) {
18169       {
18170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18171       };
18172     } catch (...) {
18173       {
18174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18175       };
18176     }
18177   }
18178 }
18179
18180
18181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18182   int jresult ;
18183   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18184   std::string *arg2 = 0 ;
18185   Dali::Property::Value *arg3 = 0 ;
18186   Dali::Property::Index result;
18187
18188   arg1 = (Dali::Handle *)jarg1;
18189   if (!jarg2) {
18190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18191     return 0;
18192   }
18193   std::string arg2_str(jarg2);
18194   arg2 = &arg2_str;
18195   arg3 = (Dali::Property::Value *)jarg3;
18196   if (!arg3) {
18197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18198     return 0;
18199   }
18200   {
18201     try {
18202       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18203     } catch (std::out_of_range& e) {
18204       {
18205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18206       };
18207     } catch (std::exception& e) {
18208       {
18209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18210       };
18211     } catch (...) {
18212       {
18213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18214       };
18215     }
18216   }
18217   jresult = result;
18218
18219   //argout typemap for const std::string&
18220
18221   return jresult;
18222 }
18223
18224
18225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18226   int jresult ;
18227   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18228   std::string *arg2 = 0 ;
18229   Dali::Property::Value *arg3 = 0 ;
18230   Dali::Property::AccessMode arg4 ;
18231   Dali::Property::Index result;
18232
18233   arg1 = (Dali::Handle *)jarg1;
18234   if (!jarg2) {
18235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18236     return 0;
18237   }
18238   std::string arg2_str(jarg2);
18239   arg2 = &arg2_str;
18240   arg3 = (Dali::Property::Value *)jarg3;
18241   if (!arg3) {
18242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18243     return 0;
18244   }
18245   arg4 = (Dali::Property::AccessMode)jarg4;
18246   {
18247     try {
18248       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18249     } catch (std::out_of_range& e) {
18250       {
18251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18252       };
18253     } catch (std::exception& e) {
18254       {
18255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18256       };
18257     } catch (...) {
18258       {
18259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18260       };
18261     }
18262   }
18263   jresult = result;
18264
18265   //argout typemap for const std::string&
18266
18267   return jresult;
18268 }
18269
18270
18271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18272   void * jresult ;
18273   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18274   Dali::Property::Index arg2 ;
18275   Dali::Property::Value result;
18276
18277   arg1 = (Dali::Handle *)jarg1;
18278   arg2 = (Dali::Property::Index)jarg2;
18279   {
18280     try {
18281       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18282     } catch (std::out_of_range& e) {
18283       {
18284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18285       };
18286     } catch (std::exception& e) {
18287       {
18288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18289       };
18290     } catch (...) {
18291       {
18292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18293       };
18294     }
18295   }
18296   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18297   return jresult;
18298 }
18299
18300
18301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18302   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18303   Dali::Property::IndexContainer *arg2 = 0 ;
18304
18305   arg1 = (Dali::Handle *)jarg1;
18306   arg2 = (Dali::Property::IndexContainer *)jarg2;
18307   if (!arg2) {
18308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18309     return ;
18310   }
18311   {
18312     try {
18313       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18314     } catch (std::out_of_range& e) {
18315       {
18316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18317       };
18318     } catch (std::exception& e) {
18319       {
18320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18321       };
18322     } catch (...) {
18323       {
18324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18325       };
18326     }
18327   }
18328 }
18329
18330
18331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18332   void * jresult ;
18333   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18334   Dali::Property::Index arg2 ;
18335   Dali::PropertyCondition *arg3 = 0 ;
18336   Dali::PropertyNotification result;
18337
18338   arg1 = (Dali::Handle *)jarg1;
18339   arg2 = (Dali::Property::Index)jarg2;
18340   arg3 = (Dali::PropertyCondition *)jarg3;
18341   if (!arg3) {
18342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18343     return 0;
18344   }
18345   {
18346     try {
18347       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18348     } catch (std::out_of_range& e) {
18349       {
18350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18351       };
18352     } catch (std::exception& e) {
18353       {
18354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18355       };
18356     } catch (...) {
18357       {
18358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18359       };
18360     }
18361   }
18362   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18363   return jresult;
18364 }
18365
18366
18367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18368   void * jresult ;
18369   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18370   Dali::Property::Index arg2 ;
18371   int arg3 ;
18372   Dali::PropertyCondition *arg4 = 0 ;
18373   Dali::PropertyNotification result;
18374
18375   arg1 = (Dali::Handle *)jarg1;
18376   arg2 = (Dali::Property::Index)jarg2;
18377   arg3 = (int)jarg3;
18378   arg4 = (Dali::PropertyCondition *)jarg4;
18379   if (!arg4) {
18380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18381     return 0;
18382   }
18383   {
18384     try {
18385       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18386     } catch (std::out_of_range& e) {
18387       {
18388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18389       };
18390     } catch (std::exception& e) {
18391       {
18392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18393       };
18394     } catch (...) {
18395       {
18396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18397       };
18398     }
18399   }
18400   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18401   return jresult;
18402 }
18403
18404
18405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18406   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18407   Dali::PropertyNotification arg2 ;
18408   Dali::PropertyNotification *argp2 ;
18409
18410   arg1 = (Dali::Handle *)jarg1;
18411   argp2 = (Dali::PropertyNotification *)jarg2;
18412   if (!argp2) {
18413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18414     return ;
18415   }
18416   arg2 = *argp2;
18417   {
18418     try {
18419       (arg1)->RemovePropertyNotification(arg2);
18420     } catch (std::out_of_range& e) {
18421       {
18422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18423       };
18424     } catch (std::exception& e) {
18425       {
18426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18427       };
18428     } catch (...) {
18429       {
18430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18431       };
18432     }
18433   }
18434 }
18435
18436
18437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18438   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18439
18440   arg1 = (Dali::Handle *)jarg1;
18441   {
18442     try {
18443       (arg1)->RemovePropertyNotifications();
18444     } catch (std::out_of_range& e) {
18445       {
18446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18447       };
18448     } catch (std::exception& e) {
18449       {
18450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18451       };
18452     } catch (...) {
18453       {
18454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18455       };
18456     }
18457   }
18458 }
18459
18460
18461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18462   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18463
18464   arg1 = (Dali::Handle *)jarg1;
18465   {
18466     try {
18467       (arg1)->RemoveConstraints();
18468     } catch (std::out_of_range& e) {
18469       {
18470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18471       };
18472     } catch (std::exception& e) {
18473       {
18474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18475       };
18476     } catch (...) {
18477       {
18478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18479       };
18480     }
18481   }
18482 }
18483
18484
18485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18486   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18487   unsigned int arg2 ;
18488
18489   arg1 = (Dali::Handle *)jarg1;
18490   arg2 = (unsigned int)jarg2;
18491   {
18492     try {
18493       (arg1)->RemoveConstraints(arg2);
18494     } catch (std::out_of_range& e) {
18495       {
18496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18497       };
18498     } catch (std::exception& e) {
18499       {
18500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18501       };
18502     } catch (...) {
18503       {
18504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18505       };
18506     }
18507   }
18508 }
18509
18510
18511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18512   int jresult ;
18513   Dali::Property::Index result;
18514
18515   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18516   jresult = result;
18517   return jresult;
18518 }
18519
18520
18521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18522   void * jresult ;
18523   Dali::Handle result;
18524
18525   {
18526     try {
18527       result = Dali::WeightObject::New();
18528     } catch (std::out_of_range& e) {
18529       {
18530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18531       };
18532     } catch (std::exception& e) {
18533       {
18534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (...) {
18537       {
18538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18539       };
18540     }
18541   }
18542   jresult = new Dali::Handle((const Dali::Handle &)result);
18543   return jresult;
18544 }
18545
18546
18547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18548   void * jresult ;
18549   Dali::TypeInfo *result = 0 ;
18550
18551   {
18552     try {
18553       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18554     } catch (std::out_of_range& e) {
18555       {
18556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18557       };
18558     } catch (std::exception& e) {
18559       {
18560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18561       };
18562     } catch (...) {
18563       {
18564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18565       };
18566     }
18567   }
18568   jresult = (void *)result;
18569   return jresult;
18570 }
18571
18572
18573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18574   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18575
18576   arg1 = (Dali::TypeInfo *)jarg1;
18577   {
18578     try {
18579       delete arg1;
18580     } catch (std::out_of_range& e) {
18581       {
18582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18583       };
18584     } catch (std::exception& e) {
18585       {
18586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18587       };
18588     } catch (...) {
18589       {
18590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18591       };
18592     }
18593   }
18594 }
18595
18596
18597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18598   void * jresult ;
18599   Dali::TypeInfo *arg1 = 0 ;
18600   Dali::TypeInfo *result = 0 ;
18601
18602   arg1 = (Dali::TypeInfo *)jarg1;
18603   if (!arg1) {
18604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18605     return 0;
18606   }
18607   {
18608     try {
18609       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18610     } catch (std::out_of_range& e) {
18611       {
18612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18613       };
18614     } catch (std::exception& e) {
18615       {
18616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18617       };
18618     } catch (...) {
18619       {
18620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18621       };
18622     }
18623   }
18624   jresult = (void *)result;
18625   return jresult;
18626 }
18627
18628
18629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18630   void * jresult ;
18631   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18632   Dali::TypeInfo *arg2 = 0 ;
18633   Dali::TypeInfo *result = 0 ;
18634
18635   arg1 = (Dali::TypeInfo *)jarg1;
18636   arg2 = (Dali::TypeInfo *)jarg2;
18637   if (!arg2) {
18638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18639     return 0;
18640   }
18641   {
18642     try {
18643       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18644     } catch (std::out_of_range& e) {
18645       {
18646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18647       };
18648     } catch (std::exception& e) {
18649       {
18650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18651       };
18652     } catch (...) {
18653       {
18654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18655       };
18656     }
18657   }
18658   jresult = (void *)result;
18659   return jresult;
18660 }
18661
18662
18663 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18664   char * jresult ;
18665   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18666   std::string *result = 0 ;
18667
18668   arg1 = (Dali::TypeInfo *)jarg1;
18669   {
18670     try {
18671       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18672     } catch (std::out_of_range& e) {
18673       {
18674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (std::exception& e) {
18677       {
18678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18679       };
18680     } catch (...) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18683       };
18684     }
18685   }
18686   jresult = SWIG_csharp_string_callback(result->c_str());
18687   return jresult;
18688 }
18689
18690
18691 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18692   char * jresult ;
18693   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18694   std::string *result = 0 ;
18695
18696   arg1 = (Dali::TypeInfo *)jarg1;
18697   {
18698     try {
18699       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18700     } catch (std::out_of_range& e) {
18701       {
18702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18703       };
18704     } catch (std::exception& e) {
18705       {
18706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (...) {
18709       {
18710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18711       };
18712     }
18713   }
18714   jresult = SWIG_csharp_string_callback(result->c_str());
18715   return jresult;
18716 }
18717
18718
18719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18720   void * jresult ;
18721   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18722   Dali::BaseHandle result;
18723
18724   arg1 = (Dali::TypeInfo *)jarg1;
18725   {
18726     try {
18727       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18728     } catch (std::out_of_range& e) {
18729       {
18730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18731       };
18732     } catch (std::exception& e) {
18733       {
18734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (...) {
18737       {
18738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18739       };
18740     }
18741   }
18742   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18743   return jresult;
18744 }
18745
18746
18747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18748   unsigned long jresult ;
18749   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18750   size_t result;
18751
18752   arg1 = (Dali::TypeInfo *)jarg1;
18753   {
18754     try {
18755       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18756     } catch (std::out_of_range& e) {
18757       {
18758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18759       };
18760     } catch (std::exception& e) {
18761       {
18762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18763       };
18764     } catch (...) {
18765       {
18766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18767       };
18768     }
18769   }
18770   jresult = (unsigned long)result;
18771   return jresult;
18772 }
18773
18774
18775 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18776   char * jresult ;
18777   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18778   size_t arg2 ;
18779   std::string result;
18780
18781   arg1 = (Dali::TypeInfo *)jarg1;
18782   arg2 = (size_t)jarg2;
18783   {
18784     try {
18785       result = (arg1)->GetActionName(arg2);
18786     } catch (std::out_of_range& e) {
18787       {
18788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18789       };
18790     } catch (std::exception& e) {
18791       {
18792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18793       };
18794     } catch (...) {
18795       {
18796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18797       };
18798     }
18799   }
18800   jresult = SWIG_csharp_string_callback((&result)->c_str());
18801   return jresult;
18802 }
18803
18804
18805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18806   unsigned long jresult ;
18807   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18808   size_t result;
18809
18810   arg1 = (Dali::TypeInfo *)jarg1;
18811   {
18812     try {
18813       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18814     } catch (std::out_of_range& e) {
18815       {
18816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (std::exception& e) {
18819       {
18820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18821       };
18822     } catch (...) {
18823       {
18824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18825       };
18826     }
18827   }
18828   jresult = (unsigned long)result;
18829   return jresult;
18830 }
18831
18832
18833 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18834   char * jresult ;
18835   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18836   size_t arg2 ;
18837   std::string result;
18838
18839   arg1 = (Dali::TypeInfo *)jarg1;
18840   arg2 = (size_t)jarg2;
18841   {
18842     try {
18843       result = (arg1)->GetSignalName(arg2);
18844     } catch (std::out_of_range& e) {
18845       {
18846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18847       };
18848     } catch (std::exception& e) {
18849       {
18850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18851       };
18852     } catch (...) {
18853       {
18854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18855       };
18856     }
18857   }
18858   jresult = SWIG_csharp_string_callback((&result)->c_str());
18859   return jresult;
18860 }
18861
18862
18863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18864   unsigned long jresult ;
18865   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18866   size_t result;
18867
18868   arg1 = (Dali::TypeInfo *)jarg1;
18869   {
18870     try {
18871       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18872     } catch (std::out_of_range& e) {
18873       {
18874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18875       };
18876     } catch (std::exception& e) {
18877       {
18878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18879       };
18880     } catch (...) {
18881       {
18882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18883       };
18884     }
18885   }
18886   jresult = (unsigned long)result;
18887   return jresult;
18888 }
18889
18890
18891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18892   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18893   Dali::Property::IndexContainer *arg2 = 0 ;
18894
18895   arg1 = (Dali::TypeInfo *)jarg1;
18896   arg2 = (Dali::Property::IndexContainer *)jarg2;
18897   if (!arg2) {
18898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18899     return ;
18900   }
18901   {
18902     try {
18903       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18904     } catch (std::out_of_range& e) {
18905       {
18906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18907       };
18908     } catch (std::exception& e) {
18909       {
18910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18911       };
18912     } catch (...) {
18913       {
18914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18915       };
18916     }
18917   }
18918 }
18919
18920
18921 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18922   char * jresult ;
18923   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18924   Dali::Property::Index arg2 ;
18925   std::string *result = 0 ;
18926
18927   arg1 = (Dali::TypeInfo *)jarg1;
18928   arg2 = (Dali::Property::Index)jarg2;
18929   {
18930     try {
18931       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18932     } catch (std::out_of_range& e) {
18933       {
18934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18935       };
18936     } catch (std::exception& e) {
18937       {
18938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18939       };
18940     } catch (...) {
18941       {
18942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18943       };
18944     }
18945   }
18946   jresult = SWIG_csharp_string_callback(result->c_str());
18947   return jresult;
18948 }
18949
18950
18951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18952   void * jresult ;
18953   Dali::TypeRegistry result;
18954
18955   {
18956     try {
18957       result = Dali::TypeRegistry::Get();
18958     } catch (std::out_of_range& e) {
18959       {
18960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18961       };
18962     } catch (std::exception& e) {
18963       {
18964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18965       };
18966     } catch (...) {
18967       {
18968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18969       };
18970     }
18971   }
18972   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18973   return jresult;
18974 }
18975
18976
18977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18978   void * jresult ;
18979   Dali::TypeRegistry *result = 0 ;
18980
18981   {
18982     try {
18983       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18984     } catch (std::out_of_range& e) {
18985       {
18986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18987       };
18988     } catch (std::exception& e) {
18989       {
18990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18991       };
18992     } catch (...) {
18993       {
18994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18995       };
18996     }
18997   }
18998   jresult = (void *)result;
18999   return jresult;
19000 }
19001
19002
19003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19004   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19005
19006   arg1 = (Dali::TypeRegistry *)jarg1;
19007   {
19008     try {
19009       delete arg1;
19010     } catch (std::out_of_range& e) {
19011       {
19012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19013       };
19014     } catch (std::exception& e) {
19015       {
19016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19017       };
19018     } catch (...) {
19019       {
19020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19021       };
19022     }
19023   }
19024 }
19025
19026
19027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19028   void * jresult ;
19029   Dali::TypeRegistry *arg1 = 0 ;
19030   Dali::TypeRegistry *result = 0 ;
19031
19032   arg1 = (Dali::TypeRegistry *)jarg1;
19033   if (!arg1) {
19034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19035     return 0;
19036   }
19037   {
19038     try {
19039       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19040     } catch (std::out_of_range& e) {
19041       {
19042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19043       };
19044     } catch (std::exception& e) {
19045       {
19046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19047       };
19048     } catch (...) {
19049       {
19050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19051       };
19052     }
19053   }
19054   jresult = (void *)result;
19055   return jresult;
19056 }
19057
19058
19059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19060   void * jresult ;
19061   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19062   Dali::TypeRegistry *arg2 = 0 ;
19063   Dali::TypeRegistry *result = 0 ;
19064
19065   arg1 = (Dali::TypeRegistry *)jarg1;
19066   arg2 = (Dali::TypeRegistry *)jarg2;
19067   if (!arg2) {
19068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19069     return 0;
19070   }
19071   {
19072     try {
19073       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19074     } catch (std::out_of_range& e) {
19075       {
19076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19077       };
19078     } catch (std::exception& e) {
19079       {
19080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19081       };
19082     } catch (...) {
19083       {
19084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19085       };
19086     }
19087   }
19088   jresult = (void *)result;
19089   return jresult;
19090 }
19091
19092
19093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19094   void * jresult ;
19095   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19096   std::string *arg2 = 0 ;
19097   Dali::TypeInfo result;
19098
19099   arg1 = (Dali::TypeRegistry *)jarg1;
19100   if (!jarg2) {
19101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19102     return 0;
19103   }
19104   std::string arg2_str(jarg2);
19105   arg2 = &arg2_str;
19106   {
19107     try {
19108       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19109     } catch (std::out_of_range& e) {
19110       {
19111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19112       };
19113     } catch (std::exception& e) {
19114       {
19115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19116       };
19117     } catch (...) {
19118       {
19119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19120       };
19121     }
19122   }
19123   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19124
19125   //argout typemap for const std::string&
19126
19127   return jresult;
19128 }
19129
19130
19131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19132   void * jresult ;
19133   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19134   std::type_info *arg2 = 0 ;
19135   Dali::TypeInfo result;
19136
19137   arg1 = (Dali::TypeRegistry *)jarg1;
19138   arg2 = (std::type_info *)jarg2;
19139   if (!arg2) {
19140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19141     return 0;
19142   }
19143   {
19144     try {
19145       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19146     } catch (std::out_of_range& e) {
19147       {
19148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19149       };
19150     } catch (std::exception& e) {
19151       {
19152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19153       };
19154     } catch (...) {
19155       {
19156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19157       };
19158     }
19159   }
19160   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19161   return jresult;
19162 }
19163
19164
19165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19166   unsigned long jresult ;
19167   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19168   size_t result;
19169
19170   arg1 = (Dali::TypeRegistry *)jarg1;
19171   {
19172     try {
19173       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19174     } catch (std::out_of_range& e) {
19175       {
19176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19177       };
19178     } catch (std::exception& e) {
19179       {
19180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19181       };
19182     } catch (...) {
19183       {
19184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19185       };
19186     }
19187   }
19188   jresult = (unsigned long)result;
19189   return jresult;
19190 }
19191
19192
19193 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19194   char * jresult ;
19195   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19196   size_t arg2 ;
19197   std::string result;
19198
19199   arg1 = (Dali::TypeRegistry *)jarg1;
19200   arg2 = (size_t)jarg2;
19201   {
19202     try {
19203       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19204     } catch (std::out_of_range& e) {
19205       {
19206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19207       };
19208     } catch (std::exception& e) {
19209       {
19210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19211       };
19212     } catch (...) {
19213       {
19214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19215       };
19216     }
19217   }
19218   jresult = SWIG_csharp_string_callback((&result)->c_str());
19219   return jresult;
19220 }
19221
19222
19223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19224   void * jresult ;
19225   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19226   Dali::TypeRegistry *result = 0 ;
19227
19228   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19229   {
19230     try {
19231       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19232     } catch (std::out_of_range& e) {
19233       {
19234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (std::exception& e) {
19237       {
19238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19239       };
19240     } catch (...) {
19241       {
19242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19243       };
19244     }
19245   }
19246   jresult = (void *)result;
19247   return jresult;
19248 }
19249
19250
19251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19252   void * jresult ;
19253   std::type_info *arg1 = 0 ;
19254   std::type_info *arg2 = 0 ;
19255   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19256   Dali::TypeRegistration *result = 0 ;
19257
19258   arg1 = (std::type_info *)jarg1;
19259   if (!arg1) {
19260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19261     return 0;
19262   }
19263   arg2 = (std::type_info *)jarg2;
19264   if (!arg2) {
19265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19266     return 0;
19267   }
19268   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19269   {
19270     try {
19271       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19272     } catch (std::out_of_range& e) {
19273       {
19274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19275       };
19276     } catch (std::exception& e) {
19277       {
19278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19279       };
19280     } catch (...) {
19281       {
19282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19283       };
19284     }
19285   }
19286   jresult = (void *)result;
19287   return jresult;
19288 }
19289
19290
19291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19292   void * jresult ;
19293   std::type_info *arg1 = 0 ;
19294   std::type_info *arg2 = 0 ;
19295   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19296   bool arg4 ;
19297   Dali::TypeRegistration *result = 0 ;
19298
19299   arg1 = (std::type_info *)jarg1;
19300   if (!arg1) {
19301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19302     return 0;
19303   }
19304   arg2 = (std::type_info *)jarg2;
19305   if (!arg2) {
19306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19307     return 0;
19308   }
19309   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19310   arg4 = jarg4 ? true : false;
19311   {
19312     try {
19313       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19314     } catch (std::out_of_range& e) {
19315       {
19316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19317       };
19318     } catch (std::exception& e) {
19319       {
19320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19321       };
19322     } catch (...) {
19323       {
19324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19325       };
19326     }
19327   }
19328   jresult = (void *)result;
19329   return jresult;
19330 }
19331
19332
19333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19334   void * jresult ;
19335   std::string *arg1 = 0 ;
19336   std::type_info *arg2 = 0 ;
19337   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19338   Dali::TypeRegistration *result = 0 ;
19339
19340   if (!jarg1) {
19341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19342     return 0;
19343   }
19344   std::string arg1_str(jarg1);
19345   arg1 = &arg1_str;
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::string 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
19371   //argout typemap for const std::string&
19372
19373   return jresult;
19374 }
19375
19376
19377 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19378   char * jresult ;
19379   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19380   std::string result;
19381
19382   arg1 = (Dali::TypeRegistration *)jarg1;
19383   {
19384     try {
19385       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19386     } catch (std::out_of_range& e) {
19387       {
19388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19389       };
19390     } catch (std::exception& e) {
19391       {
19392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19393       };
19394     } catch (...) {
19395       {
19396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19397       };
19398     }
19399   }
19400   jresult = SWIG_csharp_string_callback((&result)->c_str());
19401   return jresult;
19402 }
19403
19404
19405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19406   std::string *arg1 = 0 ;
19407   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19408
19409   if (!jarg1) {
19410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19411     return ;
19412   }
19413   std::string arg1_str(jarg1);
19414   arg1 = &arg1_str;
19415   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19416   {
19417     try {
19418       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19419     } catch (std::out_of_range& e) {
19420       {
19421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19422       };
19423     } catch (std::exception& e) {
19424       {
19425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19426       };
19427     } catch (...) {
19428       {
19429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19430       };
19431     }
19432   }
19433
19434   //argout typemap for const std::string&
19435
19436 }
19437
19438
19439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19440   std::string *arg1 = 0 ;
19441   std::string *arg2 = 0 ;
19442   int arg3 ;
19443   Dali::Property::Type arg4 ;
19444   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19445   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19446
19447   if (!jarg1) {
19448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19449     return ;
19450   }
19451   std::string arg1_str(jarg1);
19452   arg1 = &arg1_str;
19453   if (!jarg2) {
19454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19455     return ;
19456   }
19457   std::string arg2_str(jarg2);
19458   arg2 = &arg2_str;
19459   arg3 = (int)jarg3;
19460   arg4 = (Dali::Property::Type)jarg4;
19461   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19462   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19463   {
19464     try {
19465       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19466     } catch (std::out_of_range& e) {
19467       {
19468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19469       };
19470     } catch (std::exception& e) {
19471       {
19472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19473       };
19474     } catch (...) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19477       };
19478     }
19479   }
19480
19481   //argout typemap for const std::string&
19482
19483
19484   //argout typemap for const std::string&
19485
19486 }
19487
19488
19489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19490   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19491
19492   arg1 = (Dali::TypeRegistration *)jarg1;
19493   {
19494     try {
19495       delete arg1;
19496     } catch (std::out_of_range& e) {
19497       {
19498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19499       };
19500     } catch (std::exception& e) {
19501       {
19502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19503       };
19504     } catch (...) {
19505       {
19506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19507       };
19508     }
19509   }
19510 }
19511
19512
19513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19514   void * jresult ;
19515   Dali::TypeRegistration *arg1 = 0 ;
19516   std::string *arg2 = 0 ;
19517   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19518   Dali::SignalConnectorType *result = 0 ;
19519
19520   arg1 = (Dali::TypeRegistration *)jarg1;
19521   if (!arg1) {
19522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19523     return 0;
19524   }
19525   if (!jarg2) {
19526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19527     return 0;
19528   }
19529   std::string arg2_str(jarg2);
19530   arg2 = &arg2_str;
19531   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19532   {
19533     try {
19534       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19535     } catch (std::out_of_range& e) {
19536       {
19537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (std::exception& e) {
19540       {
19541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19542       };
19543     } catch (...) {
19544       {
19545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19546       };
19547     }
19548   }
19549   jresult = (void *)result;
19550
19551   //argout typemap for const std::string&
19552
19553   return jresult;
19554 }
19555
19556
19557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19558   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19559
19560   arg1 = (Dali::SignalConnectorType *)jarg1;
19561   {
19562     try {
19563       delete arg1;
19564     } catch (std::out_of_range& e) {
19565       {
19566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19567       };
19568     } catch (std::exception& e) {
19569       {
19570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19571       };
19572     } catch (...) {
19573       {
19574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19575       };
19576     }
19577   }
19578 }
19579
19580
19581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19582   void * jresult ;
19583   Dali::TypeRegistration *arg1 = 0 ;
19584   std::string *arg2 = 0 ;
19585   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19586   Dali::TypeAction *result = 0 ;
19587
19588   arg1 = (Dali::TypeRegistration *)jarg1;
19589   if (!arg1) {
19590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19591     return 0;
19592   }
19593   if (!jarg2) {
19594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19595     return 0;
19596   }
19597   std::string arg2_str(jarg2);
19598   arg2 = &arg2_str;
19599   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19600   {
19601     try {
19602       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19603     } catch (std::out_of_range& e) {
19604       {
19605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19606       };
19607     } catch (std::exception& e) {
19608       {
19609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19610       };
19611     } catch (...) {
19612       {
19613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19614       };
19615     }
19616   }
19617   jresult = (void *)result;
19618
19619   //argout typemap for const std::string&
19620
19621   return jresult;
19622 }
19623
19624
19625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19626   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19627
19628   arg1 = (Dali::TypeAction *)jarg1;
19629   {
19630     try {
19631       delete arg1;
19632     } catch (std::out_of_range& e) {
19633       {
19634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19635       };
19636     } catch (std::exception& e) {
19637       {
19638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19639       };
19640     } catch (...) {
19641       {
19642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19643       };
19644     }
19645   }
19646 }
19647
19648
19649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19650   void * jresult ;
19651   Dali::TypeRegistration *arg1 = 0 ;
19652   std::string *arg2 = 0 ;
19653   Dali::Property::Index arg3 ;
19654   Dali::Property::Type arg4 ;
19655   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19656   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19657   Dali::PropertyRegistration *result = 0 ;
19658
19659   arg1 = (Dali::TypeRegistration *)jarg1;
19660   if (!arg1) {
19661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19662     return 0;
19663   }
19664   if (!jarg2) {
19665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19666     return 0;
19667   }
19668   std::string arg2_str(jarg2);
19669   arg2 = &arg2_str;
19670   arg3 = (Dali::Property::Index)jarg3;
19671   arg4 = (Dali::Property::Type)jarg4;
19672   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19673   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19674   {
19675     try {
19676       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19677     } catch (std::out_of_range& e) {
19678       {
19679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19680       };
19681     } catch (std::exception& e) {
19682       {
19683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19684       };
19685     } catch (...) {
19686       {
19687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19688       };
19689     }
19690   }
19691   jresult = (void *)result;
19692
19693   //argout typemap for const std::string&
19694
19695   return jresult;
19696 }
19697
19698
19699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19700   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19701
19702   arg1 = (Dali::PropertyRegistration *)jarg1;
19703   {
19704     try {
19705       delete arg1;
19706     } catch (std::out_of_range& e) {
19707       {
19708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19709       };
19710     } catch (std::exception& e) {
19711       {
19712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19713       };
19714     } catch (...) {
19715       {
19716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19717       };
19718     }
19719   }
19720 }
19721
19722
19723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19724   void * jresult ;
19725   Dali::TypeRegistration *arg1 = 0 ;
19726   std::string *arg2 = 0 ;
19727   Dali::Property::Index arg3 ;
19728   Dali::Property::Type arg4 ;
19729   Dali::AnimatablePropertyRegistration *result = 0 ;
19730
19731   arg1 = (Dali::TypeRegistration *)jarg1;
19732   if (!arg1) {
19733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19734     return 0;
19735   }
19736   if (!jarg2) {
19737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19738     return 0;
19739   }
19740   std::string arg2_str(jarg2);
19741   arg2 = &arg2_str;
19742   arg3 = (Dali::Property::Index)jarg3;
19743   arg4 = (Dali::Property::Type)jarg4;
19744   {
19745     try {
19746       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19747     } catch (std::out_of_range& e) {
19748       {
19749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19750       };
19751     } catch (std::exception& e) {
19752       {
19753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19754       };
19755     } catch (...) {
19756       {
19757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19758       };
19759     }
19760   }
19761   jresult = (void *)result;
19762
19763   //argout typemap for const std::string&
19764
19765   return jresult;
19766 }
19767
19768
19769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19770   void * jresult ;
19771   Dali::TypeRegistration *arg1 = 0 ;
19772   std::string *arg2 = 0 ;
19773   Dali::Property::Index arg3 ;
19774   Dali::Property::Value *arg4 = 0 ;
19775   Dali::AnimatablePropertyRegistration *result = 0 ;
19776
19777   arg1 = (Dali::TypeRegistration *)jarg1;
19778   if (!arg1) {
19779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19780     return 0;
19781   }
19782   if (!jarg2) {
19783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19784     return 0;
19785   }
19786   std::string arg2_str(jarg2);
19787   arg2 = &arg2_str;
19788   arg3 = (Dali::Property::Index)jarg3;
19789   arg4 = (Dali::Property::Value *)jarg4;
19790   if (!arg4) {
19791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19792     return 0;
19793   }
19794   {
19795     try {
19796       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (...) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19808       };
19809     }
19810   }
19811   jresult = (void *)result;
19812
19813   //argout typemap for const std::string&
19814
19815   return jresult;
19816 }
19817
19818
19819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19820   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19821
19822   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19823   {
19824     try {
19825       delete arg1;
19826     } catch (std::out_of_range& e) {
19827       {
19828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19829       };
19830     } catch (std::exception& e) {
19831       {
19832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19833       };
19834     } catch (...) {
19835       {
19836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19837       };
19838     }
19839   }
19840 }
19841
19842
19843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19844   void * jresult ;
19845   Dali::TypeRegistration *arg1 = 0 ;
19846   std::string *arg2 = 0 ;
19847   Dali::Property::Index arg3 ;
19848   Dali::Property::Index arg4 ;
19849   unsigned int arg5 ;
19850   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19851
19852   arg1 = (Dali::TypeRegistration *)jarg1;
19853   if (!arg1) {
19854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19855     return 0;
19856   }
19857   if (!jarg2) {
19858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19859     return 0;
19860   }
19861   std::string arg2_str(jarg2);
19862   arg2 = &arg2_str;
19863   arg3 = (Dali::Property::Index)jarg3;
19864   arg4 = (Dali::Property::Index)jarg4;
19865   arg5 = (unsigned int)jarg5;
19866   {
19867     try {
19868       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19869     } catch (std::out_of_range& e) {
19870       {
19871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (std::exception& e) {
19874       {
19875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883   jresult = (void *)result;
19884
19885   //argout typemap for const std::string&
19886
19887   return jresult;
19888 }
19889
19890
19891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19892   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19893
19894   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19895   {
19896     try {
19897       delete arg1;
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19905       };
19906     } catch (...) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19909       };
19910     }
19911   }
19912 }
19913
19914
19915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19916   void * jresult ;
19917   Dali::TypeRegistration *arg1 = 0 ;
19918   std::string *arg2 = 0 ;
19919   Dali::Property::Index arg3 ;
19920   Dali::Property::Type arg4 ;
19921   Dali::ChildPropertyRegistration *result = 0 ;
19922
19923   arg1 = (Dali::TypeRegistration *)jarg1;
19924   if (!arg1) {
19925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19926     return 0;
19927   }
19928   if (!jarg2) {
19929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19930     return 0;
19931   }
19932   std::string arg2_str(jarg2);
19933   arg2 = &arg2_str;
19934   arg3 = (Dali::Property::Index)jarg3;
19935   arg4 = (Dali::Property::Type)jarg4;
19936   {
19937     try {
19938       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19939     } catch (std::out_of_range& e) {
19940       {
19941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19942       };
19943     } catch (std::exception& e) {
19944       {
19945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19946       };
19947     } catch (...) {
19948       {
19949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19950       };
19951     }
19952   }
19953   jresult = (void *)result;
19954
19955   //argout typemap for const std::string&
19956
19957   return jresult;
19958 }
19959
19960
19961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19962   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19963
19964   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19965   {
19966     try {
19967       delete arg1;
19968     } catch (std::out_of_range& e) {
19969       {
19970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19971       };
19972     } catch (std::exception& e) {
19973       {
19974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19975       };
19976     } catch (...) {
19977       {
19978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19979       };
19980     }
19981   }
19982 }
19983
19984
19985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19986   unsigned int jresult ;
19987   std::string *arg1 = 0 ;
19988   std::type_info *arg2 = 0 ;
19989   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19990   bool result;
19991
19992   if (!jarg1) {
19993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19994     return 0;
19995   }
19996   std::string arg1_str(jarg1);
19997   arg1 = &arg1_str;
19998   arg2 = (std::type_info *)jarg2;
19999   if (!arg2) {
20000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20001     return 0;
20002   }
20003   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20004   {
20005     try {
20006       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20007     } catch (std::out_of_range& e) {
20008       {
20009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20010       };
20011     } catch (std::exception& e) {
20012       {
20013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20014       };
20015     } catch (...) {
20016       {
20017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20018       };
20019     }
20020   }
20021   jresult = result;
20022
20023   //argout typemap for const std::string&
20024
20025   return jresult;
20026 }
20027
20028
20029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20030   unsigned int jresult ;
20031   std::string *arg1 = 0 ;
20032   std::string *arg2 = 0 ;
20033   Dali::Property::Index arg3 ;
20034   Dali::Property::Type arg4 ;
20035   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20036   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20037   bool result;
20038
20039   if (!jarg1) {
20040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20041     return 0;
20042   }
20043   std::string arg1_str(jarg1);
20044   arg1 = &arg1_str;
20045   if (!jarg2) {
20046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20047     return 0;
20048   }
20049   std::string arg2_str(jarg2);
20050   arg2 = &arg2_str;
20051   arg3 = (Dali::Property::Index)jarg3;
20052   arg4 = (Dali::Property::Type)jarg4;
20053   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20054   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20055   {
20056     try {
20057       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20058     } catch (std::out_of_range& e) {
20059       {
20060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20061       };
20062     } catch (std::exception& e) {
20063       {
20064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20065       };
20066     } catch (...) {
20067       {
20068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20069       };
20070     }
20071   }
20072   jresult = result;
20073
20074   //argout typemap for const std::string&
20075
20076
20077   //argout typemap for const std::string&
20078
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20084   float jresult ;
20085   float result;
20086
20087   result = (float)(float)Dali::ParentOrigin::TOP;
20088   jresult = result;
20089   return jresult;
20090 }
20091
20092
20093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20094   float jresult ;
20095   float result;
20096
20097   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20098   jresult = result;
20099   return jresult;
20100 }
20101
20102
20103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20104   float jresult ;
20105   float result;
20106
20107   result = (float)(float)Dali::ParentOrigin::LEFT;
20108   jresult = result;
20109   return jresult;
20110 }
20111
20112
20113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20114   float jresult ;
20115   float result;
20116
20117   result = (float)(float)Dali::ParentOrigin::RIGHT;
20118   jresult = result;
20119   return jresult;
20120 }
20121
20122
20123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20124   float jresult ;
20125   float result;
20126
20127   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20128   jresult = result;
20129   return jresult;
20130 }
20131
20132
20133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20134   void * jresult ;
20135   Dali::Vector3 *result = 0 ;
20136
20137   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20138   jresult = (void *)result;
20139   return jresult;
20140 }
20141
20142
20143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20144   void * jresult ;
20145   Dali::Vector3 *result = 0 ;
20146
20147   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20148   jresult = (void *)result;
20149   return jresult;
20150 }
20151
20152
20153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20154   void * jresult ;
20155   Dali::Vector3 *result = 0 ;
20156
20157   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20158   jresult = (void *)result;
20159   return jresult;
20160 }
20161
20162
20163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20164   void * jresult ;
20165   Dali::Vector3 *result = 0 ;
20166
20167   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20168   jresult = (void *)result;
20169   return jresult;
20170 }
20171
20172
20173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20174   void * jresult ;
20175   Dali::Vector3 *result = 0 ;
20176
20177   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20178   jresult = (void *)result;
20179   return jresult;
20180 }
20181
20182
20183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20184   void * jresult ;
20185   Dali::Vector3 *result = 0 ;
20186
20187   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20188   jresult = (void *)result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20194   void * jresult ;
20195   Dali::Vector3 *result = 0 ;
20196
20197   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20198   jresult = (void *)result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20204   void * jresult ;
20205   Dali::Vector3 *result = 0 ;
20206
20207   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20208   jresult = (void *)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20214   void * jresult ;
20215   Dali::Vector3 *result = 0 ;
20216
20217   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20224   float jresult ;
20225   float result;
20226
20227   result = (float)(float)Dali::AnchorPoint::TOP;
20228   jresult = result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20234   float jresult ;
20235   float result;
20236
20237   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20238   jresult = result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20244   float jresult ;
20245   float result;
20246
20247   result = (float)(float)Dali::AnchorPoint::LEFT;
20248   jresult = result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20254   float jresult ;
20255   float result;
20256
20257   result = (float)(float)Dali::AnchorPoint::RIGHT;
20258   jresult = result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20264   float jresult ;
20265   float result;
20266
20267   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20268   jresult = result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20274   void * jresult ;
20275   Dali::Vector3 *result = 0 ;
20276
20277   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20284   void * jresult ;
20285   Dali::Vector3 *result = 0 ;
20286
20287   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20294   void * jresult ;
20295   Dali::Vector3 *result = 0 ;
20296
20297   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20298   jresult = (void *)result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20304   void * jresult ;
20305   Dali::Vector3 *result = 0 ;
20306
20307   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20308   jresult = (void *)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20314   void * jresult ;
20315   Dali::Vector3 *result = 0 ;
20316
20317   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20318   jresult = (void *)result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20324   void * jresult ;
20325   Dali::Vector3 *result = 0 ;
20326
20327   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20328   jresult = (void *)result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20334   void * jresult ;
20335   Dali::Vector3 *result = 0 ;
20336
20337   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20338   jresult = (void *)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20344   void * jresult ;
20345   Dali::Vector3 *result = 0 ;
20346
20347   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20354   void * jresult ;
20355   Dali::Vector3 *result = 0 ;
20356
20357   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20358   jresult = (void *)result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20364   void * jresult ;
20365   Dali::Vector4 *result = 0 ;
20366
20367   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20374   void * jresult ;
20375   Dali::Vector4 *result = 0 ;
20376
20377   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20378   jresult = (void *)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20384   void * jresult ;
20385   Dali::Vector4 *result = 0 ;
20386
20387   result = (Dali::Vector4 *)&Dali::Color::RED;
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20394   void * jresult ;
20395   Dali::Vector4 *result = 0 ;
20396
20397   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20398   jresult = (void *)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20404   void * jresult ;
20405   Dali::Vector4 *result = 0 ;
20406
20407   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20414   void * jresult ;
20415   Dali::Vector4 *result = 0 ;
20416
20417   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20424   void * jresult ;
20425   Dali::Vector4 *result = 0 ;
20426
20427   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20434   void * jresult ;
20435   Dali::Vector4 *result = 0 ;
20436
20437   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20438   jresult = (void *)result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20444   void * jresult ;
20445   Dali::Vector4 *result = 0 ;
20446
20447   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20448   jresult = (void *)result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20454   float jresult ;
20455   float result;
20456
20457   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20458   jresult = result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20464   float jresult ;
20465   float result;
20466
20467   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20468   jresult = result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20474   float jresult ;
20475   float result;
20476
20477   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20478   jresult = result;
20479   return jresult;
20480 }
20481
20482
20483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20484   float jresult ;
20485   float result;
20486
20487   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20488   jresult = result;
20489   return jresult;
20490 }
20491
20492
20493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20494   float jresult ;
20495   float result;
20496
20497   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20498   jresult = result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20504   float jresult ;
20505   float result;
20506
20507   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20508   jresult = result;
20509   return jresult;
20510 }
20511
20512
20513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20514   float jresult ;
20515   float result;
20516
20517   result = (float)(float)Dali::Math::PI;
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20524   float jresult ;
20525   float result;
20526
20527   result = (float)(float)Dali::Math::PI_2;
20528   jresult = result;
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20534   float jresult ;
20535   float result;
20536
20537   result = (float)(float)Dali::Math::PI_4;
20538   jresult = result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20544   float jresult ;
20545   float result;
20546
20547   result = (float)(float)Dali::Math::PI_OVER_180;
20548   jresult = result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20554   float jresult ;
20555   float result;
20556
20557   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20558   jresult = result;
20559   return jresult;
20560 }
20561
20562
20563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20564   int jresult ;
20565   Dali::ResizePolicy::Type result;
20566
20567   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20568   jresult = (int)result;
20569   return jresult;
20570 }
20571
20572
20573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20574   unsigned long jresult ;
20575   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20576   Dali::VectorBase::SizeType result;
20577
20578   arg1 = (Dali::VectorBase *)jarg1;
20579   {
20580     try {
20581       result = ((Dali::VectorBase const *)arg1)->Count();
20582     } catch (std::out_of_range& e) {
20583       {
20584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20585       };
20586     } catch (std::exception& e) {
20587       {
20588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20589       };
20590     } catch (...) {
20591       {
20592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20593       };
20594     }
20595   }
20596   jresult = (unsigned long)result;
20597   return jresult;
20598 }
20599
20600
20601 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20602   unsigned long jresult ;
20603   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20604   Dali::VectorBase::SizeType result;
20605
20606   arg1 = (Dali::VectorBase *)jarg1;
20607   {
20608     try {
20609       result = ((Dali::VectorBase const *)arg1)->Size();
20610     } catch (std::out_of_range& e) {
20611       {
20612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20613       };
20614     } catch (std::exception& e) {
20615       {
20616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20617       };
20618     } catch (...) {
20619       {
20620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20621       };
20622     }
20623   }
20624   jresult = (unsigned long)result;
20625   return jresult;
20626 }
20627
20628
20629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20630   unsigned int jresult ;
20631   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20632   bool result;
20633
20634   arg1 = (Dali::VectorBase *)jarg1;
20635   {
20636     try {
20637       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20638     } catch (std::out_of_range& e) {
20639       {
20640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20641       };
20642     } catch (std::exception& e) {
20643       {
20644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20645       };
20646     } catch (...) {
20647       {
20648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20649       };
20650     }
20651   }
20652   jresult = result;
20653   return jresult;
20654 }
20655
20656
20657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20658   unsigned long jresult ;
20659   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20660   Dali::VectorBase::SizeType result;
20661
20662   arg1 = (Dali::VectorBase *)jarg1;
20663   {
20664     try {
20665       result = ((Dali::VectorBase const *)arg1)->Capacity();
20666     } catch (std::out_of_range& e) {
20667       {
20668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20669       };
20670     } catch (std::exception& e) {
20671       {
20672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20673       };
20674     } catch (...) {
20675       {
20676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20677       };
20678     }
20679   }
20680   jresult = (unsigned long)result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20686   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20687
20688   arg1 = (Dali::VectorBase *)jarg1;
20689   {
20690     try {
20691       (arg1)->Release();
20692     } catch (std::out_of_range& e) {
20693       {
20694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20695       };
20696     } catch (std::exception& e) {
20697       {
20698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20699       };
20700     } catch (...) {
20701       {
20702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20703       };
20704     }
20705   }
20706 }
20707
20708
20709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20710   void * jresult ;
20711   Dali::Image *result = 0 ;
20712
20713   {
20714     try {
20715       result = (Dali::Image *)new Dali::Image();
20716     } catch (std::out_of_range& e) {
20717       {
20718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (std::exception& e) {
20721       {
20722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20723       };
20724     } catch (...) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20727       };
20728     }
20729   }
20730   jresult = (void *)result;
20731   return jresult;
20732 }
20733
20734
20735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20736   Dali::Image *arg1 = (Dali::Image *) 0 ;
20737
20738   arg1 = (Dali::Image *)jarg1;
20739   {
20740     try {
20741       delete arg1;
20742     } catch (std::out_of_range& e) {
20743       {
20744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20745       };
20746     } catch (std::exception& e) {
20747       {
20748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20749       };
20750     } catch (...) {
20751       {
20752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20753       };
20754     }
20755   }
20756 }
20757
20758
20759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20760   void * jresult ;
20761   Dali::Image *arg1 = 0 ;
20762   Dali::Image *result = 0 ;
20763
20764   arg1 = (Dali::Image *)jarg1;
20765   if (!arg1) {
20766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20767     return 0;
20768   }
20769   {
20770     try {
20771       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20772     } catch (std::out_of_range& e) {
20773       {
20774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20775       };
20776     } catch (std::exception& e) {
20777       {
20778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (...) {
20781       {
20782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20783       };
20784     }
20785   }
20786   jresult = (void *)result;
20787   return jresult;
20788 }
20789
20790
20791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20792   void * jresult ;
20793   Dali::Image *arg1 = (Dali::Image *) 0 ;
20794   Dali::Image *arg2 = 0 ;
20795   Dali::Image *result = 0 ;
20796
20797   arg1 = (Dali::Image *)jarg1;
20798   arg2 = (Dali::Image *)jarg2;
20799   if (!arg2) {
20800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20801     return 0;
20802   }
20803   {
20804     try {
20805       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20806     } catch (std::out_of_range& e) {
20807       {
20808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20809       };
20810     } catch (std::exception& e) {
20811       {
20812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20813       };
20814     } catch (...) {
20815       {
20816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20817       };
20818     }
20819   }
20820   jresult = (void *)result;
20821   return jresult;
20822 }
20823
20824
20825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20826   void * jresult ;
20827   Dali::BaseHandle arg1 ;
20828   Dali::BaseHandle *argp1 ;
20829   Dali::Image result;
20830
20831   argp1 = (Dali::BaseHandle *)jarg1;
20832   if (!argp1) {
20833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20834     return 0;
20835   }
20836   arg1 = *argp1;
20837   {
20838     try {
20839       result = Dali::Image::DownCast(arg1);
20840     } catch (std::out_of_range& e) {
20841       {
20842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20843       };
20844     } catch (std::exception& e) {
20845       {
20846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20847       };
20848     } catch (...) {
20849       {
20850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20851       };
20852     }
20853   }
20854   jresult = new Dali::Image((const Dali::Image &)result);
20855   return jresult;
20856 }
20857
20858
20859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20860   unsigned int jresult ;
20861   Dali::Image *arg1 = (Dali::Image *) 0 ;
20862   unsigned int result;
20863
20864   arg1 = (Dali::Image *)jarg1;
20865   {
20866     try {
20867       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20868     } catch (std::out_of_range& e) {
20869       {
20870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (std::exception& e) {
20873       {
20874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (...) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20879       };
20880     }
20881   }
20882   jresult = result;
20883   return jresult;
20884 }
20885
20886
20887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20888   unsigned int jresult ;
20889   Dali::Image *arg1 = (Dali::Image *) 0 ;
20890   unsigned int result;
20891
20892   arg1 = (Dali::Image *)jarg1;
20893   {
20894     try {
20895       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20896     } catch (std::out_of_range& e) {
20897       {
20898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20899       };
20900     } catch (std::exception& e) {
20901       {
20902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20903       };
20904     } catch (...) {
20905       {
20906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20907       };
20908     }
20909   }
20910   jresult = result;
20911   return jresult;
20912 }
20913
20914
20915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20916   void * jresult ;
20917   Dali::Image *arg1 = (Dali::Image *) 0 ;
20918   Dali::Image::ImageSignalType *result = 0 ;
20919
20920   arg1 = (Dali::Image *)jarg1;
20921   {
20922     try {
20923       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20924     } catch (std::out_of_range& e) {
20925       {
20926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20927       };
20928     } catch (std::exception& e) {
20929       {
20930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20931       };
20932     } catch (...) {
20933       {
20934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20935       };
20936     }
20937   }
20938   jresult = (void *)result;
20939   return jresult;
20940 }
20941
20942
20943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20944   int jresult ;
20945   Dali::Pixel::Format result;
20946
20947   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20948   jresult = (int)result;
20949   return jresult;
20950 }
20951
20952
20953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20954   int jresult ;
20955   Dali::Pixel::Format result;
20956
20957   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20958   jresult = (int)result;
20959   return jresult;
20960 }
20961
20962
20963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20964   unsigned int jresult ;
20965   Dali::Pixel::Format arg1 ;
20966   bool result;
20967
20968   arg1 = (Dali::Pixel::Format)jarg1;
20969   {
20970     try {
20971       result = (bool)Dali::Pixel::HasAlpha(arg1);
20972     } catch (std::out_of_range& e) {
20973       {
20974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20975       };
20976     } catch (std::exception& e) {
20977       {
20978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20979       };
20980     } catch (...) {
20981       {
20982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20983       };
20984     }
20985   }
20986   jresult = result;
20987   return jresult;
20988 }
20989
20990
20991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20992   unsigned int jresult ;
20993   Dali::Pixel::Format arg1 ;
20994   unsigned int result;
20995
20996   arg1 = (Dali::Pixel::Format)jarg1;
20997   {
20998     try {
20999       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21000     } catch (std::out_of_range& e) {
21001       {
21002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21003       };
21004     } catch (std::exception& e) {
21005       {
21006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21007       };
21008     } catch (...) {
21009       {
21010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21011       };
21012     }
21013   }
21014   jresult = result;
21015   return jresult;
21016 }
21017
21018
21019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21020   Dali::Pixel::Format arg1 ;
21021   int *arg2 = 0 ;
21022   int *arg3 = 0 ;
21023
21024   arg1 = (Dali::Pixel::Format)jarg1;
21025   arg2 = (int *)jarg2;
21026   if (!arg2) {
21027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21028     return ;
21029   }
21030   arg3 = (int *)jarg3;
21031   if (!arg3) {
21032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21033     return ;
21034   }
21035   {
21036     try {
21037       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21038     } catch (std::out_of_range& e) {
21039       {
21040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21041       };
21042     } catch (std::exception& e) {
21043       {
21044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21045       };
21046     } catch (...) {
21047       {
21048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21049       };
21050     }
21051   }
21052 }
21053
21054
21055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21056   void * jresult ;
21057   unsigned char *arg1 = (unsigned char *) 0 ;
21058   unsigned int arg2 ;
21059   unsigned int arg3 ;
21060   unsigned int arg4 ;
21061   Dali::Pixel::Format arg5 ;
21062   Dali::PixelData::ReleaseFunction arg6 ;
21063   Dali::PixelData result;
21064
21065   arg1 = jarg1;
21066   arg2 = (unsigned int)jarg2;
21067   arg3 = (unsigned int)jarg3;
21068   arg4 = (unsigned int)jarg4;
21069   arg5 = (Dali::Pixel::Format)jarg5;
21070   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21071   {
21072     try {
21073       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21074     } catch (std::out_of_range& e) {
21075       {
21076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21077       };
21078     } catch (std::exception& e) {
21079       {
21080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21081       };
21082     } catch (...) {
21083       {
21084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21085       };
21086     }
21087   }
21088   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21089
21090
21091   return jresult;
21092 }
21093
21094
21095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21096   void * jresult ;
21097   Dali::PixelData *result = 0 ;
21098
21099   {
21100     try {
21101       result = (Dali::PixelData *)new Dali::PixelData();
21102     } catch (std::out_of_range& e) {
21103       {
21104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21105       };
21106     } catch (std::exception& e) {
21107       {
21108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21109       };
21110     } catch (...) {
21111       {
21112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21113       };
21114     }
21115   }
21116   jresult = (void *)result;
21117   return jresult;
21118 }
21119
21120
21121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21122   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21123
21124   arg1 = (Dali::PixelData *)jarg1;
21125   {
21126     try {
21127       delete arg1;
21128     } catch (std::out_of_range& e) {
21129       {
21130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21131       };
21132     } catch (std::exception& e) {
21133       {
21134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21135       };
21136     } catch (...) {
21137       {
21138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21139       };
21140     }
21141   }
21142 }
21143
21144
21145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21146   void * jresult ;
21147   Dali::PixelData *arg1 = 0 ;
21148   Dali::PixelData *result = 0 ;
21149
21150   arg1 = (Dali::PixelData *)jarg1;
21151   if (!arg1) {
21152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21153     return 0;
21154   }
21155   {
21156     try {
21157       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21158     } catch (std::out_of_range& e) {
21159       {
21160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21161       };
21162     } catch (std::exception& e) {
21163       {
21164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21169       };
21170     }
21171   }
21172   jresult = (void *)result;
21173   return jresult;
21174 }
21175
21176
21177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21178   void * jresult ;
21179   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21180   Dali::PixelData *arg2 = 0 ;
21181   Dali::PixelData *result = 0 ;
21182
21183   arg1 = (Dali::PixelData *)jarg1;
21184   arg2 = (Dali::PixelData *)jarg2;
21185   if (!arg2) {
21186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21187     return 0;
21188   }
21189   {
21190     try {
21191       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21192     } catch (std::out_of_range& e) {
21193       {
21194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21195       };
21196     } catch (std::exception& e) {
21197       {
21198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21199       };
21200     } catch (...) {
21201       {
21202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21203       };
21204     }
21205   }
21206   jresult = (void *)result;
21207   return jresult;
21208 }
21209
21210
21211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21212   unsigned int jresult ;
21213   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21214   unsigned int result;
21215
21216   arg1 = (Dali::PixelData *)jarg1;
21217   {
21218     try {
21219       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21220     } catch (std::out_of_range& e) {
21221       {
21222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21223       };
21224     } catch (std::exception& e) {
21225       {
21226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21227       };
21228     } catch (...) {
21229       {
21230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21231       };
21232     }
21233   }
21234   jresult = result;
21235   return jresult;
21236 }
21237
21238
21239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21240   unsigned int jresult ;
21241   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21242   unsigned int result;
21243
21244   arg1 = (Dali::PixelData *)jarg1;
21245   {
21246     try {
21247       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21248     } catch (std::out_of_range& e) {
21249       {
21250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21251       };
21252     } catch (std::exception& e) {
21253       {
21254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (...) {
21257       {
21258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21259       };
21260     }
21261   }
21262   jresult = result;
21263   return jresult;
21264 }
21265
21266
21267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21268   int jresult ;
21269   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21270   Dali::Pixel::Format result;
21271
21272   arg1 = (Dali::PixelData *)jarg1;
21273   {
21274     try {
21275       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21276     } catch (std::out_of_range& e) {
21277       {
21278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21279       };
21280     } catch (std::exception& e) {
21281       {
21282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21283       };
21284     } catch (...) {
21285       {
21286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21287       };
21288     }
21289   }
21290   jresult = (int)result;
21291   return jresult;
21292 }
21293
21294
21295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21296   unsigned int jresult ;
21297   unsigned int result;
21298
21299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21300   jresult = result;
21301   return jresult;
21302 }
21303
21304
21305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21306   unsigned int jresult ;
21307   unsigned int result;
21308
21309   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21310   jresult = result;
21311   return jresult;
21312 }
21313
21314
21315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21316   unsigned int jresult ;
21317   unsigned int result;
21318
21319   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21320   jresult = result;
21321   return jresult;
21322 }
21323
21324
21325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21326   unsigned int jresult ;
21327   unsigned int result;
21328
21329   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21330   jresult = result;
21331   return jresult;
21332 }
21333
21334
21335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21336   unsigned int jresult ;
21337   unsigned int result;
21338
21339   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21340   jresult = result;
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21346   unsigned int jresult ;
21347   unsigned int result;
21348
21349   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21350   jresult = result;
21351   return jresult;
21352 }
21353
21354
21355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21356   void * jresult ;
21357   Dali::TextureType::Type arg1 ;
21358   Dali::Pixel::Format arg2 ;
21359   unsigned int arg3 ;
21360   unsigned int arg4 ;
21361   Dali::Texture result;
21362
21363   arg1 = (Dali::TextureType::Type)jarg1;
21364   arg2 = (Dali::Pixel::Format)jarg2;
21365   arg3 = (unsigned int)jarg3;
21366   arg4 = (unsigned int)jarg4;
21367   {
21368     try {
21369       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21370     } catch (std::out_of_range& e) {
21371       {
21372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21373       };
21374     } catch (std::exception& e) {
21375       {
21376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21377       };
21378     } catch (...) {
21379       {
21380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21381       };
21382     }
21383   }
21384   jresult = new Dali::Texture((const Dali::Texture &)result);
21385   return jresult;
21386 }
21387
21388
21389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21390   void * jresult ;
21391   NativeImageInterface *arg1 = 0 ;
21392   Dali::Texture result;
21393
21394   arg1 = (NativeImageInterface *)jarg1;
21395   if (!arg1) {
21396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21397     return 0;
21398   }
21399   {
21400     try {
21401       result = Dali::Texture::New(*arg1);
21402     } catch (std::out_of_range& e) {
21403       {
21404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21405       };
21406     } catch (std::exception& e) {
21407       {
21408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21409       };
21410     } catch (...) {
21411       {
21412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21413       };
21414     }
21415   }
21416   jresult = new Dali::Texture((const Dali::Texture &)result);
21417   return jresult;
21418 }
21419
21420
21421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21422   void * jresult ;
21423   Dali::Texture *result = 0 ;
21424
21425   {
21426     try {
21427       result = (Dali::Texture *)new Dali::Texture();
21428     } catch (std::out_of_range& e) {
21429       {
21430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21431       };
21432     } catch (std::exception& e) {
21433       {
21434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21435       };
21436     } catch (...) {
21437       {
21438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21439       };
21440     }
21441   }
21442   jresult = (void *)result;
21443   return jresult;
21444 }
21445
21446
21447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21448   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21449
21450   arg1 = (Dali::Texture *)jarg1;
21451   {
21452     try {
21453       delete arg1;
21454     } catch (std::out_of_range& e) {
21455       {
21456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21457       };
21458     } catch (std::exception& e) {
21459       {
21460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21461       };
21462     } catch (...) {
21463       {
21464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21465       };
21466     }
21467   }
21468 }
21469
21470
21471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21472   void * jresult ;
21473   Dali::Texture *arg1 = 0 ;
21474   Dali::Texture *result = 0 ;
21475
21476   arg1 = (Dali::Texture *)jarg1;
21477   if (!arg1) {
21478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21479     return 0;
21480   }
21481   {
21482     try {
21483       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21484     } catch (std::out_of_range& e) {
21485       {
21486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21487       };
21488     } catch (std::exception& e) {
21489       {
21490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (...) {
21493       {
21494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21495       };
21496     }
21497   }
21498   jresult = (void *)result;
21499   return jresult;
21500 }
21501
21502
21503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21504   void * jresult ;
21505   Dali::BaseHandle arg1 ;
21506   Dali::BaseHandle *argp1 ;
21507   Dali::Texture result;
21508
21509   argp1 = (Dali::BaseHandle *)jarg1;
21510   if (!argp1) {
21511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21512     return 0;
21513   }
21514   arg1 = *argp1;
21515   {
21516     try {
21517       result = Dali::Texture::DownCast(arg1);
21518     } catch (std::out_of_range& e) {
21519       {
21520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21521       };
21522     } catch (std::exception& e) {
21523       {
21524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21525       };
21526     } catch (...) {
21527       {
21528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21529       };
21530     }
21531   }
21532   jresult = new Dali::Texture((const Dali::Texture &)result);
21533   return jresult;
21534 }
21535
21536
21537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21538   void * jresult ;
21539   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21540   Dali::Texture *arg2 = 0 ;
21541   Dali::Texture *result = 0 ;
21542
21543   arg1 = (Dali::Texture *)jarg1;
21544   arg2 = (Dali::Texture *)jarg2;
21545   if (!arg2) {
21546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21547     return 0;
21548   }
21549   {
21550     try {
21551       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21552     } catch (std::out_of_range& e) {
21553       {
21554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21555       };
21556     } catch (std::exception& e) {
21557       {
21558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (...) {
21561       {
21562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21563       };
21564     }
21565   }
21566   jresult = (void *)result;
21567   return jresult;
21568 }
21569
21570
21571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21572   unsigned int jresult ;
21573   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21574   Dali::PixelData arg2 ;
21575   Dali::PixelData *argp2 ;
21576   bool result;
21577
21578   arg1 = (Dali::Texture *)jarg1;
21579   argp2 = (Dali::PixelData *)jarg2;
21580   if (!argp2) {
21581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21582     return 0;
21583   }
21584   arg2 = *argp2;
21585   {
21586     try {
21587       result = (bool)(arg1)->Upload(arg2);
21588     } catch (std::out_of_range& e) {
21589       {
21590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21591       };
21592     } catch (std::exception& e) {
21593       {
21594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21595       };
21596     } catch (...) {
21597       {
21598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21599       };
21600     }
21601   }
21602   jresult = result;
21603   return jresult;
21604 }
21605
21606
21607 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) {
21608   unsigned int jresult ;
21609   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21610   Dali::PixelData arg2 ;
21611   unsigned int arg3 ;
21612   unsigned int arg4 ;
21613   unsigned int arg5 ;
21614   unsigned int arg6 ;
21615   unsigned int arg7 ;
21616   unsigned int arg8 ;
21617   Dali::PixelData *argp2 ;
21618   bool result;
21619
21620   arg1 = (Dali::Texture *)jarg1;
21621   argp2 = (Dali::PixelData *)jarg2;
21622   if (!argp2) {
21623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21624     return 0;
21625   }
21626   arg2 = *argp2;
21627   arg3 = (unsigned int)jarg3;
21628   arg4 = (unsigned int)jarg4;
21629   arg5 = (unsigned int)jarg5;
21630   arg6 = (unsigned int)jarg6;
21631   arg7 = (unsigned int)jarg7;
21632   arg8 = (unsigned int)jarg8;
21633   {
21634     try {
21635       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21636     } catch (std::out_of_range& e) {
21637       {
21638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21639       };
21640     } catch (std::exception& e) {
21641       {
21642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21643       };
21644     } catch (...) {
21645       {
21646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21647       };
21648     }
21649   }
21650   jresult = result;
21651   return jresult;
21652 }
21653
21654
21655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21656   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21657
21658   arg1 = (Dali::Texture *)jarg1;
21659   {
21660     try {
21661       (arg1)->GenerateMipmaps();
21662     } catch (std::out_of_range& e) {
21663       {
21664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21665       };
21666     } catch (std::exception& e) {
21667       {
21668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21669       };
21670     } catch (...) {
21671       {
21672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21673       };
21674     }
21675   }
21676 }
21677
21678
21679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21680   unsigned int jresult ;
21681   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21682   unsigned int result;
21683
21684   arg1 = (Dali::Texture *)jarg1;
21685   {
21686     try {
21687       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21688     } catch (std::out_of_range& e) {
21689       {
21690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (std::exception& e) {
21693       {
21694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21695       };
21696     } catch (...) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21699       };
21700     }
21701   }
21702   jresult = result;
21703   return jresult;
21704 }
21705
21706
21707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21708   unsigned int jresult ;
21709   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21710   unsigned int result;
21711
21712   arg1 = (Dali::Texture *)jarg1;
21713   {
21714     try {
21715       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21716     } catch (std::out_of_range& e) {
21717       {
21718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21719       };
21720     } catch (std::exception& e) {
21721       {
21722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21723       };
21724     } catch (...) {
21725       {
21726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21727       };
21728     }
21729   }
21730   jresult = result;
21731   return jresult;
21732 }
21733
21734
21735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21736   void * jresult ;
21737   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21738   Dali::Texture *result = 0 ;
21739
21740   arg1 = (Dali::Internal::Texture *)jarg1;
21741   {
21742     try {
21743       result = (Dali::Texture *)new Dali::Texture(arg1);
21744     } catch (std::out_of_range& e) {
21745       {
21746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21747       };
21748     } catch (std::exception& e) {
21749       {
21750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (...) {
21753       {
21754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21755       };
21756     }
21757   }
21758   jresult = (void *)result;
21759   return jresult;
21760 }
21761
21762
21763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21764   void * jresult ;
21765   Dali::Sampler result;
21766
21767   {
21768     try {
21769       result = Dali::Sampler::New();
21770     } catch (std::out_of_range& e) {
21771       {
21772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21773       };
21774     } catch (std::exception& e) {
21775       {
21776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21777       };
21778     } catch (...) {
21779       {
21780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21781       };
21782     }
21783   }
21784   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21785   return jresult;
21786 }
21787
21788
21789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21790   void * jresult ;
21791   Dali::Sampler *result = 0 ;
21792
21793   {
21794     try {
21795       result = (Dali::Sampler *)new Dali::Sampler();
21796     } catch (std::out_of_range& e) {
21797       {
21798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (std::exception& e) {
21801       {
21802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21803       };
21804     } catch (...) {
21805       {
21806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21807       };
21808     }
21809   }
21810   jresult = (void *)result;
21811   return jresult;
21812 }
21813
21814
21815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21816   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21817
21818   arg1 = (Dali::Sampler *)jarg1;
21819   {
21820     try {
21821       delete arg1;
21822     } catch (std::out_of_range& e) {
21823       {
21824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21825       };
21826     } catch (std::exception& e) {
21827       {
21828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21829       };
21830     } catch (...) {
21831       {
21832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21833       };
21834     }
21835   }
21836 }
21837
21838
21839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21840   void * jresult ;
21841   Dali::Sampler *arg1 = 0 ;
21842   Dali::Sampler *result = 0 ;
21843
21844   arg1 = (Dali::Sampler *)jarg1;
21845   if (!arg1) {
21846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21847     return 0;
21848   }
21849   {
21850     try {
21851       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21852     } catch (std::out_of_range& e) {
21853       {
21854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21855       };
21856     } catch (std::exception& e) {
21857       {
21858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21859       };
21860     } catch (...) {
21861       {
21862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21863       };
21864     }
21865   }
21866   jresult = (void *)result;
21867   return jresult;
21868 }
21869
21870
21871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21872   void * jresult ;
21873   Dali::BaseHandle arg1 ;
21874   Dali::BaseHandle *argp1 ;
21875   Dali::Sampler result;
21876
21877   argp1 = (Dali::BaseHandle *)jarg1;
21878   if (!argp1) {
21879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21880     return 0;
21881   }
21882   arg1 = *argp1;
21883   {
21884     try {
21885       result = Dali::Sampler::DownCast(arg1);
21886     } catch (std::out_of_range& e) {
21887       {
21888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21889       };
21890     } catch (std::exception& e) {
21891       {
21892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21893       };
21894     } catch (...) {
21895       {
21896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21897       };
21898     }
21899   }
21900   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21901   return jresult;
21902 }
21903
21904
21905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21906   void * jresult ;
21907   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21908   Dali::Sampler *arg2 = 0 ;
21909   Dali::Sampler *result = 0 ;
21910
21911   arg1 = (Dali::Sampler *)jarg1;
21912   arg2 = (Dali::Sampler *)jarg2;
21913   if (!arg2) {
21914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21915     return 0;
21916   }
21917   {
21918     try {
21919       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21920     } catch (std::out_of_range& e) {
21921       {
21922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21923       };
21924     } catch (std::exception& e) {
21925       {
21926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21927       };
21928     } catch (...) {
21929       {
21930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21931       };
21932     }
21933   }
21934   jresult = (void *)result;
21935   return jresult;
21936 }
21937
21938
21939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21940   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21941   Dali::FilterMode::Type arg2 ;
21942   Dali::FilterMode::Type arg3 ;
21943
21944   arg1 = (Dali::Sampler *)jarg1;
21945   arg2 = (Dali::FilterMode::Type)jarg2;
21946   arg3 = (Dali::FilterMode::Type)jarg3;
21947   {
21948     try {
21949       (arg1)->SetFilterMode(arg2,arg3);
21950     } catch (std::out_of_range& e) {
21951       {
21952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21953       };
21954     } catch (std::exception& e) {
21955       {
21956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21957       };
21958     } catch (...) {
21959       {
21960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21961       };
21962     }
21963   }
21964 }
21965
21966
21967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21968   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21969   Dali::WrapMode::Type arg2 ;
21970   Dali::WrapMode::Type arg3 ;
21971
21972   arg1 = (Dali::Sampler *)jarg1;
21973   arg2 = (Dali::WrapMode::Type)jarg2;
21974   arg3 = (Dali::WrapMode::Type)jarg3;
21975   {
21976     try {
21977       (arg1)->SetWrapMode(arg2,arg3);
21978     } catch (std::out_of_range& e) {
21979       {
21980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21981       };
21982     } catch (std::exception& e) {
21983       {
21984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21985       };
21986     } catch (...) {
21987       {
21988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21989       };
21990     }
21991   }
21992 }
21993
21994
21995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21996   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21997   Dali::WrapMode::Type arg2 ;
21998   Dali::WrapMode::Type arg3 ;
21999   Dali::WrapMode::Type arg4 ;
22000
22001   arg1 = (Dali::Sampler *)jarg1;
22002   arg2 = (Dali::WrapMode::Type)jarg2;
22003   arg3 = (Dali::WrapMode::Type)jarg3;
22004   arg4 = (Dali::WrapMode::Type)jarg4;
22005   {
22006     try {
22007       (arg1)->SetWrapMode(arg2,arg3,arg4);
22008     } catch (std::out_of_range& e) {
22009       {
22010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22011       };
22012     } catch (std::exception& e) {
22013       {
22014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22015       };
22016     } catch (...) {
22017       {
22018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22019       };
22020     }
22021   }
22022 }
22023
22024
22025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22026   void * jresult ;
22027   Dali::TextureSet result;
22028
22029   {
22030     try {
22031       result = Dali::TextureSet::New();
22032     } catch (std::out_of_range& e) {
22033       {
22034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22035       };
22036     } catch (std::exception& e) {
22037       {
22038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22039       };
22040     } catch (...) {
22041       {
22042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22043       };
22044     }
22045   }
22046   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22047   return jresult;
22048 }
22049
22050
22051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22052   void * jresult ;
22053   Dali::TextureSet *result = 0 ;
22054
22055   {
22056     try {
22057       result = (Dali::TextureSet *)new Dali::TextureSet();
22058     } catch (std::out_of_range& e) {
22059       {
22060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22061       };
22062     } catch (std::exception& e) {
22063       {
22064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22065       };
22066     } catch (...) {
22067       {
22068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22069       };
22070     }
22071   }
22072   jresult = (void *)result;
22073   return jresult;
22074 }
22075
22076
22077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22078   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22079
22080   arg1 = (Dali::TextureSet *)jarg1;
22081   {
22082     try {
22083       delete arg1;
22084     } catch (std::out_of_range& e) {
22085       {
22086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22087       };
22088     } catch (std::exception& e) {
22089       {
22090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22091       };
22092     } catch (...) {
22093       {
22094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22095       };
22096     }
22097   }
22098 }
22099
22100
22101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22102   void * jresult ;
22103   Dali::TextureSet *arg1 = 0 ;
22104   Dali::TextureSet *result = 0 ;
22105
22106   arg1 = (Dali::TextureSet *)jarg1;
22107   if (!arg1) {
22108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22109     return 0;
22110   }
22111   {
22112     try {
22113       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22114     } catch (std::out_of_range& e) {
22115       {
22116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22117       };
22118     } catch (std::exception& e) {
22119       {
22120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (...) {
22123       {
22124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22125       };
22126     }
22127   }
22128   jresult = (void *)result;
22129   return jresult;
22130 }
22131
22132
22133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22134   void * jresult ;
22135   Dali::BaseHandle arg1 ;
22136   Dali::BaseHandle *argp1 ;
22137   Dali::TextureSet result;
22138
22139   argp1 = (Dali::BaseHandle *)jarg1;
22140   if (!argp1) {
22141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22142     return 0;
22143   }
22144   arg1 = *argp1;
22145   {
22146     try {
22147       result = Dali::TextureSet::DownCast(arg1);
22148     } catch (std::out_of_range& e) {
22149       {
22150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22151       };
22152     } catch (std::exception& e) {
22153       {
22154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22155       };
22156     } catch (...) {
22157       {
22158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22159       };
22160     }
22161   }
22162   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22163   return jresult;
22164 }
22165
22166
22167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22168   void * jresult ;
22169   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22170   Dali::TextureSet *arg2 = 0 ;
22171   Dali::TextureSet *result = 0 ;
22172
22173   arg1 = (Dali::TextureSet *)jarg1;
22174   arg2 = (Dali::TextureSet *)jarg2;
22175   if (!arg2) {
22176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22177     return 0;
22178   }
22179   {
22180     try {
22181       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22182     } catch (std::out_of_range& e) {
22183       {
22184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22185       };
22186     } catch (std::exception& e) {
22187       {
22188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22189       };
22190     } catch (...) {
22191       {
22192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22193       };
22194     }
22195   }
22196   jresult = (void *)result;
22197   return jresult;
22198 }
22199
22200
22201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22202   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22203   size_t arg2 ;
22204   Dali::Texture arg3 ;
22205   Dali::Texture *argp3 ;
22206
22207   arg1 = (Dali::TextureSet *)jarg1;
22208   arg2 = (size_t)jarg2;
22209   argp3 = (Dali::Texture *)jarg3;
22210   if (!argp3) {
22211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22212     return ;
22213   }
22214   arg3 = *argp3;
22215   {
22216     try {
22217       (arg1)->SetTexture(arg2,arg3);
22218     } catch (std::out_of_range& e) {
22219       {
22220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22221       };
22222     } catch (std::exception& e) {
22223       {
22224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22225       };
22226     } catch (...) {
22227       {
22228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22229       };
22230     }
22231   }
22232 }
22233
22234
22235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22236   void * jresult ;
22237   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22238   size_t arg2 ;
22239   Dali::Texture result;
22240
22241   arg1 = (Dali::TextureSet *)jarg1;
22242   arg2 = (size_t)jarg2;
22243   {
22244     try {
22245       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22246     } catch (std::out_of_range& e) {
22247       {
22248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22249       };
22250     } catch (std::exception& e) {
22251       {
22252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22253       };
22254     } catch (...) {
22255       {
22256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22257       };
22258     }
22259   }
22260   jresult = new Dali::Texture((const Dali::Texture &)result);
22261   return jresult;
22262 }
22263
22264
22265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22266   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22267   size_t arg2 ;
22268   Dali::Sampler arg3 ;
22269   Dali::Sampler *argp3 ;
22270
22271   arg1 = (Dali::TextureSet *)jarg1;
22272   arg2 = (size_t)jarg2;
22273   argp3 = (Dali::Sampler *)jarg3;
22274   if (!argp3) {
22275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22276     return ;
22277   }
22278   arg3 = *argp3;
22279   {
22280     try {
22281       (arg1)->SetSampler(arg2,arg3);
22282     } catch (std::out_of_range& e) {
22283       {
22284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22285       };
22286     } catch (std::exception& e) {
22287       {
22288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22289       };
22290     } catch (...) {
22291       {
22292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22293       };
22294     }
22295   }
22296 }
22297
22298
22299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22300   void * jresult ;
22301   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22302   size_t arg2 ;
22303   Dali::Sampler result;
22304
22305   arg1 = (Dali::TextureSet *)jarg1;
22306   arg2 = (size_t)jarg2;
22307   {
22308     try {
22309       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22310     } catch (std::out_of_range& e) {
22311       {
22312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22313       };
22314     } catch (std::exception& e) {
22315       {
22316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22317       };
22318     } catch (...) {
22319       {
22320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22321       };
22322     }
22323   }
22324   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22325   return jresult;
22326 }
22327
22328
22329 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22330   unsigned long jresult ;
22331   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22332   size_t result;
22333
22334   arg1 = (Dali::TextureSet *)jarg1;
22335   {
22336     try {
22337       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22338     } catch (std::out_of_range& e) {
22339       {
22340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22341       };
22342     } catch (std::exception& e) {
22343       {
22344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22345       };
22346     } catch (...) {
22347       {
22348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22349       };
22350     }
22351   }
22352   jresult = (unsigned long)result;
22353   return jresult;
22354 }
22355
22356
22357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22358   void * jresult ;
22359   Dali::Property::Map *arg1 = 0 ;
22360   Dali::PropertyBuffer result;
22361
22362   arg1 = (Dali::Property::Map *)jarg1;
22363   if (!arg1) {
22364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22365     return 0;
22366   }
22367   {
22368     try {
22369       result = Dali::PropertyBuffer::New(*arg1);
22370     } catch (std::out_of_range& e) {
22371       {
22372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (std::exception& e) {
22375       {
22376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22385   return jresult;
22386 }
22387
22388
22389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22390   void * jresult ;
22391   Dali::PropertyBuffer *result = 0 ;
22392
22393   {
22394     try {
22395       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22396     } catch (std::out_of_range& e) {
22397       {
22398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22399       };
22400     } catch (std::exception& e) {
22401       {
22402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22403       };
22404     } catch (...) {
22405       {
22406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22407       };
22408     }
22409   }
22410   jresult = (void *)result;
22411   return jresult;
22412 }
22413
22414
22415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22416   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22417
22418   arg1 = (Dali::PropertyBuffer *)jarg1;
22419   {
22420     try {
22421       delete arg1;
22422     } catch (std::out_of_range& e) {
22423       {
22424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22425       };
22426     } catch (std::exception& e) {
22427       {
22428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22429       };
22430     } catch (...) {
22431       {
22432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22433       };
22434     }
22435   }
22436 }
22437
22438
22439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22440   void * jresult ;
22441   Dali::PropertyBuffer *arg1 = 0 ;
22442   Dali::PropertyBuffer *result = 0 ;
22443
22444   arg1 = (Dali::PropertyBuffer *)jarg1;
22445   if (!arg1) {
22446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22447     return 0;
22448   }
22449   {
22450     try {
22451       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22452     } catch (std::out_of_range& e) {
22453       {
22454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (std::exception& e) {
22457       {
22458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22459       };
22460     } catch (...) {
22461       {
22462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22463       };
22464     }
22465   }
22466   jresult = (void *)result;
22467   return jresult;
22468 }
22469
22470
22471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22472   void * jresult ;
22473   Dali::BaseHandle arg1 ;
22474   Dali::BaseHandle *argp1 ;
22475   Dali::PropertyBuffer result;
22476
22477   argp1 = (Dali::BaseHandle *)jarg1;
22478   if (!argp1) {
22479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22480     return 0;
22481   }
22482   arg1 = *argp1;
22483   {
22484     try {
22485       result = Dali::PropertyBuffer::DownCast(arg1);
22486     } catch (std::out_of_range& e) {
22487       {
22488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22489       };
22490     } catch (std::exception& e) {
22491       {
22492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22493       };
22494     } catch (...) {
22495       {
22496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22497       };
22498     }
22499   }
22500   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22501   return jresult;
22502 }
22503
22504
22505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22506   void * jresult ;
22507   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22508   Dali::PropertyBuffer *arg2 = 0 ;
22509   Dali::PropertyBuffer *result = 0 ;
22510
22511   arg1 = (Dali::PropertyBuffer *)jarg1;
22512   arg2 = (Dali::PropertyBuffer *)jarg2;
22513   if (!arg2) {
22514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22515     return 0;
22516   }
22517   {
22518     try {
22519       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22520     } catch (std::out_of_range& e) {
22521       {
22522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22523       };
22524     } catch (std::exception& e) {
22525       {
22526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22527       };
22528     } catch (...) {
22529       {
22530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22531       };
22532     }
22533   }
22534   jresult = (void *)result;
22535   return jresult;
22536 }
22537
22538
22539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22540   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22541   void *arg2 = (void *) 0 ;
22542   std::size_t arg3 ;
22543
22544   arg1 = (Dali::PropertyBuffer *)jarg1;
22545   arg2 = jarg2;
22546   arg3 = (std::size_t)jarg3;
22547   {
22548     try {
22549       (arg1)->SetData((void const *)arg2,arg3);
22550     } catch (std::out_of_range& e) {
22551       {
22552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22553       };
22554     } catch (std::exception& e) {
22555       {
22556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22557       };
22558     } catch (...) {
22559       {
22560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22561       };
22562     }
22563   }
22564 }
22565
22566
22567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22568   unsigned long jresult ;
22569   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22570   std::size_t result;
22571
22572   arg1 = (Dali::PropertyBuffer *)jarg1;
22573   {
22574     try {
22575       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22576     } catch (std::out_of_range& e) {
22577       {
22578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22579       };
22580     } catch (std::exception& e) {
22581       {
22582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22583       };
22584     } catch (...) {
22585       {
22586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22587       };
22588     }
22589   }
22590   jresult = (unsigned long)result;
22591   return jresult;
22592 }
22593
22594
22595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22596   void * jresult ;
22597   Dali::Geometry result;
22598
22599   {
22600     try {
22601       result = Dali::Geometry::New();
22602     } catch (std::out_of_range& e) {
22603       {
22604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22605       };
22606     } catch (std::exception& e) {
22607       {
22608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22609       };
22610     } catch (...) {
22611       {
22612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22613       };
22614     }
22615   }
22616   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22617   return jresult;
22618 }
22619
22620
22621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22622   void * jresult ;
22623   Dali::Geometry *result = 0 ;
22624
22625   {
22626     try {
22627       result = (Dali::Geometry *)new Dali::Geometry();
22628     } catch (std::out_of_range& e) {
22629       {
22630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22631       };
22632     } catch (std::exception& e) {
22633       {
22634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22635       };
22636     } catch (...) {
22637       {
22638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22639       };
22640     }
22641   }
22642   jresult = (void *)result;
22643   return jresult;
22644 }
22645
22646
22647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22648   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22649
22650   arg1 = (Dali::Geometry *)jarg1;
22651   {
22652     try {
22653       delete arg1;
22654     } catch (std::out_of_range& e) {
22655       {
22656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22657       };
22658     } catch (std::exception& e) {
22659       {
22660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22661       };
22662     } catch (...) {
22663       {
22664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22665       };
22666     }
22667   }
22668 }
22669
22670
22671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22672   void * jresult ;
22673   Dali::Geometry *arg1 = 0 ;
22674   Dali::Geometry *result = 0 ;
22675
22676   arg1 = (Dali::Geometry *)jarg1;
22677   if (!arg1) {
22678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22679     return 0;
22680   }
22681   {
22682     try {
22683       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22684     } catch (std::out_of_range& e) {
22685       {
22686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22687       };
22688     } catch (std::exception& e) {
22689       {
22690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22691       };
22692     } catch (...) {
22693       {
22694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22695       };
22696     }
22697   }
22698   jresult = (void *)result;
22699   return jresult;
22700 }
22701
22702
22703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22704   void * jresult ;
22705   Dali::BaseHandle arg1 ;
22706   Dali::BaseHandle *argp1 ;
22707   Dali::Geometry result;
22708
22709   argp1 = (Dali::BaseHandle *)jarg1;
22710   if (!argp1) {
22711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22712     return 0;
22713   }
22714   arg1 = *argp1;
22715   {
22716     try {
22717       result = Dali::Geometry::DownCast(arg1);
22718     } catch (std::out_of_range& e) {
22719       {
22720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22721       };
22722     } catch (std::exception& e) {
22723       {
22724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22725       };
22726     } catch (...) {
22727       {
22728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22729       };
22730     }
22731   }
22732   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22733   return jresult;
22734 }
22735
22736
22737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22738   void * jresult ;
22739   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22740   Dali::Geometry *arg2 = 0 ;
22741   Dali::Geometry *result = 0 ;
22742
22743   arg1 = (Dali::Geometry *)jarg1;
22744   arg2 = (Dali::Geometry *)jarg2;
22745   if (!arg2) {
22746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22747     return 0;
22748   }
22749   {
22750     try {
22751       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22752     } catch (std::out_of_range& e) {
22753       {
22754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22755       };
22756     } catch (std::exception& e) {
22757       {
22758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22759       };
22760     } catch (...) {
22761       {
22762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22763       };
22764     }
22765   }
22766   jresult = (void *)result;
22767   return jresult;
22768 }
22769
22770
22771 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22772   unsigned long jresult ;
22773   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22774   Dali::PropertyBuffer *arg2 = 0 ;
22775   std::size_t result;
22776
22777   arg1 = (Dali::Geometry *)jarg1;
22778   arg2 = (Dali::PropertyBuffer *)jarg2;
22779   if (!arg2) {
22780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22781     return 0;
22782   }
22783   {
22784     try {
22785       result = (arg1)->AddVertexBuffer(*arg2);
22786     } catch (std::out_of_range& e) {
22787       {
22788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22789       };
22790     } catch (std::exception& e) {
22791       {
22792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22793       };
22794     } catch (...) {
22795       {
22796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22797       };
22798     }
22799   }
22800   jresult = (unsigned long)result;
22801   return jresult;
22802 }
22803
22804
22805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22806   unsigned long jresult ;
22807   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22808   std::size_t result;
22809
22810   arg1 = (Dali::Geometry *)jarg1;
22811   {
22812     try {
22813       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22814     } catch (std::out_of_range& e) {
22815       {
22816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22817       };
22818     } catch (std::exception& e) {
22819       {
22820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22821       };
22822     } catch (...) {
22823       {
22824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22825       };
22826     }
22827   }
22828   jresult = (unsigned long)result;
22829   return jresult;
22830 }
22831
22832
22833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22834   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22835   std::size_t arg2 ;
22836
22837   arg1 = (Dali::Geometry *)jarg1;
22838   arg2 = (std::size_t)jarg2;
22839   {
22840     try {
22841       (arg1)->RemoveVertexBuffer(arg2);
22842     } catch (std::out_of_range& e) {
22843       {
22844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22845       };
22846     } catch (std::exception& e) {
22847       {
22848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22849       };
22850     } catch (...) {
22851       {
22852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22853       };
22854     }
22855   }
22856 }
22857
22858
22859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22860   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22861   unsigned short *arg2 = (unsigned short *) 0 ;
22862   size_t arg3 ;
22863
22864   arg1 = (Dali::Geometry *)jarg1;
22865   arg2 = jarg2;
22866   arg3 = (size_t)jarg3;
22867   {
22868     try {
22869       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22870     } catch (std::out_of_range& e) {
22871       {
22872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22873       };
22874     } catch (std::exception& e) {
22875       {
22876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22877       };
22878     } catch (...) {
22879       {
22880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22881       };
22882     }
22883   }
22884
22885
22886 }
22887
22888
22889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22890   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22891   Dali::Geometry::Type arg2 ;
22892
22893   arg1 = (Dali::Geometry *)jarg1;
22894   arg2 = (Dali::Geometry::Type)jarg2;
22895   {
22896     try {
22897       (arg1)->SetType(arg2);
22898     } catch (std::out_of_range& e) {
22899       {
22900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22901       };
22902     } catch (std::exception& e) {
22903       {
22904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22905       };
22906     } catch (...) {
22907       {
22908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22909       };
22910     }
22911   }
22912 }
22913
22914
22915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22916   int jresult ;
22917   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22918   Dali::Geometry::Type result;
22919
22920   arg1 = (Dali::Geometry *)jarg1;
22921   {
22922     try {
22923       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22924     } catch (std::out_of_range& e) {
22925       {
22926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22927       };
22928     } catch (std::exception& e) {
22929       {
22930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22931       };
22932     } catch (...) {
22933       {
22934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22935       };
22936     }
22937   }
22938   jresult = (int)result;
22939   return jresult;
22940 }
22941
22942
22943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22944   void * jresult ;
22945   Dali::Shader::Hint *result = 0 ;
22946
22947   {
22948     try {
22949       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22950     } catch (std::out_of_range& e) {
22951       {
22952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22953       };
22954     } catch (std::exception& e) {
22955       {
22956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22957       };
22958     } catch (...) {
22959       {
22960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22961       };
22962     }
22963   }
22964   jresult = (void *)result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22970   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22971
22972   arg1 = (Dali::Shader::Hint *)jarg1;
22973   {
22974     try {
22975       delete arg1;
22976     } catch (std::out_of_range& e) {
22977       {
22978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22979       };
22980     } catch (std::exception& e) {
22981       {
22982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22983       };
22984     } catch (...) {
22985       {
22986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22987       };
22988     }
22989   }
22990 }
22991
22992
22993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22994   int jresult ;
22995   int result;
22996
22997   result = (int)Dali::Shader::Property::PROGRAM;
22998   jresult = (int)result;
22999   return jresult;
23000 }
23001
23002
23003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23004   void * jresult ;
23005   Dali::Shader::Property *result = 0 ;
23006
23007   {
23008     try {
23009       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23010     } catch (std::out_of_range& e) {
23011       {
23012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23013       };
23014     } catch (std::exception& e) {
23015       {
23016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23017       };
23018     } catch (...) {
23019       {
23020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23021       };
23022     }
23023   }
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23030   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23031
23032   arg1 = (Dali::Shader::Property *)jarg1;
23033   {
23034     try {
23035       delete arg1;
23036     } catch (std::out_of_range& e) {
23037       {
23038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23039       };
23040     } catch (std::exception& e) {
23041       {
23042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23043       };
23044     } catch (...) {
23045       {
23046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23047       };
23048     }
23049   }
23050 }
23051
23052
23053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23054   void * jresult ;
23055   std::string *arg1 = 0 ;
23056   std::string *arg2 = 0 ;
23057   Dali::Shader::Hint::Value arg3 ;
23058   Dali::Shader result;
23059
23060   if (!jarg1) {
23061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23062     return 0;
23063   }
23064   std::string arg1_str(jarg1);
23065   arg1 = &arg1_str;
23066   if (!jarg2) {
23067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23068     return 0;
23069   }
23070   std::string arg2_str(jarg2);
23071   arg2 = &arg2_str;
23072   arg3 = (Dali::Shader::Hint::Value)jarg3;
23073   {
23074     try {
23075       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23076     } catch (std::out_of_range& e) {
23077       {
23078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23079       };
23080     } catch (std::exception& e) {
23081       {
23082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23083       };
23084     } catch (...) {
23085       {
23086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23087       };
23088     }
23089   }
23090   jresult = new Dali::Shader((const Dali::Shader &)result);
23091
23092   //argout typemap for const std::string&
23093
23094
23095   //argout typemap for const std::string&
23096
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23102   void * jresult ;
23103   std::string *arg1 = 0 ;
23104   std::string *arg2 = 0 ;
23105   Dali::Shader result;
23106
23107   if (!jarg1) {
23108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23109     return 0;
23110   }
23111   std::string arg1_str(jarg1);
23112   arg1 = &arg1_str;
23113   if (!jarg2) {
23114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23115     return 0;
23116   }
23117   std::string arg2_str(jarg2);
23118   arg2 = &arg2_str;
23119   {
23120     try {
23121       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23122     } catch (std::out_of_range& e) {
23123       {
23124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23125       };
23126     } catch (std::exception& e) {
23127       {
23128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23129       };
23130     } catch (...) {
23131       {
23132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23133       };
23134     }
23135   }
23136   jresult = new Dali::Shader((const Dali::Shader &)result);
23137
23138   //argout typemap for const std::string&
23139
23140
23141   //argout typemap for const std::string&
23142
23143   return jresult;
23144 }
23145
23146
23147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23148   void * jresult ;
23149   Dali::Shader *result = 0 ;
23150
23151   {
23152     try {
23153       result = (Dali::Shader *)new Dali::Shader();
23154     } catch (std::out_of_range& e) {
23155       {
23156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23157       };
23158     } catch (std::exception& e) {
23159       {
23160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23161       };
23162     } catch (...) {
23163       {
23164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23165       };
23166     }
23167   }
23168   jresult = (void *)result;
23169   return jresult;
23170 }
23171
23172
23173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23174   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23175
23176   arg1 = (Dali::Shader *)jarg1;
23177   {
23178     try {
23179       delete arg1;
23180     } catch (std::out_of_range& e) {
23181       {
23182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23183       };
23184     } catch (std::exception& e) {
23185       {
23186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23187       };
23188     } catch (...) {
23189       {
23190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23191       };
23192     }
23193   }
23194 }
23195
23196
23197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23198   void * jresult ;
23199   Dali::Shader *arg1 = 0 ;
23200   Dali::Shader *result = 0 ;
23201
23202   arg1 = (Dali::Shader *)jarg1;
23203   if (!arg1) {
23204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23205     return 0;
23206   }
23207   {
23208     try {
23209       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23210     } catch (std::out_of_range& e) {
23211       {
23212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23213       };
23214     } catch (std::exception& e) {
23215       {
23216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23217       };
23218     } catch (...) {
23219       {
23220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23221       };
23222     }
23223   }
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23230   void * jresult ;
23231   Dali::BaseHandle arg1 ;
23232   Dali::BaseHandle *argp1 ;
23233   Dali::Shader result;
23234
23235   argp1 = (Dali::BaseHandle *)jarg1;
23236   if (!argp1) {
23237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23238     return 0;
23239   }
23240   arg1 = *argp1;
23241   {
23242     try {
23243       result = Dali::Shader::DownCast(arg1);
23244     } catch (std::out_of_range& e) {
23245       {
23246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23247       };
23248     } catch (std::exception& e) {
23249       {
23250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23251       };
23252     } catch (...) {
23253       {
23254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23255       };
23256     }
23257   }
23258   jresult = new Dali::Shader((const Dali::Shader &)result);
23259   return jresult;
23260 }
23261
23262
23263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23264   void * jresult ;
23265   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23266   Dali::Shader *arg2 = 0 ;
23267   Dali::Shader *result = 0 ;
23268
23269   arg1 = (Dali::Shader *)jarg1;
23270   arg2 = (Dali::Shader *)jarg2;
23271   if (!arg2) {
23272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23273     return 0;
23274   }
23275   {
23276     try {
23277       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23278     } catch (std::out_of_range& e) {
23279       {
23280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23281       };
23282     } catch (std::exception& e) {
23283       {
23284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23285       };
23286     } catch (...) {
23287       {
23288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23289       };
23290     }
23291   }
23292   jresult = (void *)result;
23293   return jresult;
23294 }
23295
23296
23297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23298   int jresult ;
23299   int result;
23300
23301   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23302   jresult = (int)result;
23303   return jresult;
23304 }
23305
23306
23307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23308   int jresult ;
23309   int result;
23310
23311   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23312   jresult = (int)result;
23313   return jresult;
23314 }
23315
23316
23317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23318   int jresult ;
23319   int result;
23320
23321   result = (int)Dali::Renderer::Property::BLEND_MODE;
23322   jresult = (int)result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23328   int jresult ;
23329   int result;
23330
23331   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23332   jresult = (int)result;
23333   return jresult;
23334 }
23335
23336
23337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23338   int jresult ;
23339   int result;
23340
23341   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23342   jresult = (int)result;
23343   return jresult;
23344 }
23345
23346
23347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23348   int jresult ;
23349   int result;
23350
23351   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23352   jresult = (int)result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23358   int jresult ;
23359   int result;
23360
23361   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23362   jresult = (int)result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23368   int jresult ;
23369   int result;
23370
23371   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23372   jresult = (int)result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23378   int jresult ;
23379   int result;
23380
23381   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23382   jresult = (int)result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23388   int jresult ;
23389   int result;
23390
23391   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23398   int jresult ;
23399   int result;
23400
23401   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23402   jresult = (int)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23408   int jresult ;
23409   int result;
23410
23411   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23418   int jresult ;
23419   int result;
23420
23421   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23422   jresult = (int)result;
23423   return jresult;
23424 }
23425
23426
23427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23428   int jresult ;
23429   int result;
23430
23431   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23432   jresult = (int)result;
23433   return jresult;
23434 }
23435
23436
23437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23438   int jresult ;
23439   int result;
23440
23441   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23442   jresult = (int)result;
23443   return jresult;
23444 }
23445
23446
23447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23448   int jresult ;
23449   int result;
23450
23451   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23452   jresult = (int)result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23458   int jresult ;
23459   int result;
23460
23461   result = (int)Dali::Renderer::Property::RENDER_MODE;
23462   jresult = (int)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23468   int jresult ;
23469   int result;
23470
23471   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23472   jresult = (int)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23478   int jresult ;
23479   int result;
23480
23481   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23482   jresult = (int)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23488   int jresult ;
23489   int result;
23490
23491   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23492   jresult = (int)result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23498   int jresult ;
23499   int result;
23500
23501   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23502   jresult = (int)result;
23503   return jresult;
23504 }
23505
23506
23507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23508   int jresult ;
23509   int result;
23510
23511   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23512   jresult = (int)result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23518   int jresult ;
23519   int result;
23520
23521   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23522   jresult = (int)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23528   int jresult ;
23529   int result;
23530
23531   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23532   jresult = (int)result;
23533   return jresult;
23534 }
23535
23536
23537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23538   void * jresult ;
23539   Dali::Renderer::Property *result = 0 ;
23540
23541   {
23542     try {
23543       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23544     } catch (std::out_of_range& e) {
23545       {
23546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23547       };
23548     } catch (std::exception& e) {
23549       {
23550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23551       };
23552     } catch (...) {
23553       {
23554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23555       };
23556     }
23557   }
23558   jresult = (void *)result;
23559   return jresult;
23560 }
23561
23562
23563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23564   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23565
23566   arg1 = (Dali::Renderer::Property *)jarg1;
23567   {
23568     try {
23569       delete arg1;
23570     } catch (std::out_of_range& e) {
23571       {
23572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23573       };
23574     } catch (std::exception& e) {
23575       {
23576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23577       };
23578     } catch (...) {
23579       {
23580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23581       };
23582     }
23583   }
23584 }
23585
23586
23587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23588   void * jresult ;
23589   Dali::Geometry *arg1 = 0 ;
23590   Dali::Shader *arg2 = 0 ;
23591   Dali::Renderer result;
23592
23593   arg1 = (Dali::Geometry *)jarg1;
23594   if (!arg1) {
23595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23596     return 0;
23597   }
23598   arg2 = (Dali::Shader *)jarg2;
23599   if (!arg2) {
23600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23601     return 0;
23602   }
23603   {
23604     try {
23605       result = Dali::Renderer::New(*arg1,*arg2);
23606     } catch (std::out_of_range& e) {
23607       {
23608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23609       };
23610     } catch (std::exception& e) {
23611       {
23612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23613       };
23614     } catch (...) {
23615       {
23616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23617       };
23618     }
23619   }
23620   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23621   return jresult;
23622 }
23623
23624
23625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23626   void * jresult ;
23627   Dali::Renderer *result = 0 ;
23628
23629   {
23630     try {
23631       result = (Dali::Renderer *)new Dali::Renderer();
23632     } catch (std::out_of_range& e) {
23633       {
23634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (std::exception& e) {
23637       {
23638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (...) {
23641       {
23642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23643       };
23644     }
23645   }
23646   jresult = (void *)result;
23647   return jresult;
23648 }
23649
23650
23651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23652   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23653
23654   arg1 = (Dali::Renderer *)jarg1;
23655   {
23656     try {
23657       delete arg1;
23658     } catch (std::out_of_range& e) {
23659       {
23660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23661       };
23662     } catch (std::exception& e) {
23663       {
23664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23665       };
23666     } catch (...) {
23667       {
23668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23669       };
23670     }
23671   }
23672 }
23673
23674
23675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23676   void * jresult ;
23677   Dali::Renderer *arg1 = 0 ;
23678   Dali::Renderer *result = 0 ;
23679
23680   arg1 = (Dali::Renderer *)jarg1;
23681   if (!arg1) {
23682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23683     return 0;
23684   }
23685   {
23686     try {
23687       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23688     } catch (std::out_of_range& e) {
23689       {
23690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23691       };
23692     } catch (std::exception& e) {
23693       {
23694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23695       };
23696     } catch (...) {
23697       {
23698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23699       };
23700     }
23701   }
23702   jresult = (void *)result;
23703   return jresult;
23704 }
23705
23706
23707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23708   void * jresult ;
23709   Dali::BaseHandle arg1 ;
23710   Dali::BaseHandle *argp1 ;
23711   Dali::Renderer result;
23712
23713   argp1 = (Dali::BaseHandle *)jarg1;
23714   if (!argp1) {
23715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23716     return 0;
23717   }
23718   arg1 = *argp1;
23719   {
23720     try {
23721       result = Dali::Renderer::DownCast(arg1);
23722     } catch (std::out_of_range& e) {
23723       {
23724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23725       };
23726     } catch (std::exception& e) {
23727       {
23728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23729       };
23730     } catch (...) {
23731       {
23732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23733       };
23734     }
23735   }
23736   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23737   return jresult;
23738 }
23739
23740
23741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23742   void * jresult ;
23743   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23744   Dali::Renderer *arg2 = 0 ;
23745   Dali::Renderer *result = 0 ;
23746
23747   arg1 = (Dali::Renderer *)jarg1;
23748   arg2 = (Dali::Renderer *)jarg2;
23749   if (!arg2) {
23750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23751     return 0;
23752   }
23753   {
23754     try {
23755       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23756     } catch (std::out_of_range& e) {
23757       {
23758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23759       };
23760     } catch (std::exception& e) {
23761       {
23762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23763       };
23764     } catch (...) {
23765       {
23766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23767       };
23768     }
23769   }
23770   jresult = (void *)result;
23771   return jresult;
23772 }
23773
23774
23775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23776   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23777   Dali::Geometry *arg2 = 0 ;
23778
23779   arg1 = (Dali::Renderer *)jarg1;
23780   arg2 = (Dali::Geometry *)jarg2;
23781   if (!arg2) {
23782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23783     return ;
23784   }
23785   {
23786     try {
23787       (arg1)->SetGeometry(*arg2);
23788     } catch (std::out_of_range& e) {
23789       {
23790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23791       };
23792     } catch (std::exception& e) {
23793       {
23794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23795       };
23796     } catch (...) {
23797       {
23798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23799       };
23800     }
23801   }
23802 }
23803
23804
23805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23806   void * jresult ;
23807   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23808   Dali::Geometry result;
23809
23810   arg1 = (Dali::Renderer *)jarg1;
23811   {
23812     try {
23813       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23814     } catch (std::out_of_range& e) {
23815       {
23816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23817       };
23818     } catch (std::exception& e) {
23819       {
23820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23825       };
23826     }
23827   }
23828   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23829   return jresult;
23830 }
23831
23832
23833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23834   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23835   int arg2 ;
23836   int arg3 ;
23837
23838   arg1 = (Dali::Renderer *)jarg1;
23839   arg2 = (int)jarg2;
23840   arg3 = (int)jarg3;
23841   {
23842     try {
23843       (arg1)->SetIndexRange(arg2,arg3);
23844     } catch (std::out_of_range& e) {
23845       {
23846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23847       };
23848     } catch (std::exception& e) {
23849       {
23850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23851       };
23852     } catch (...) {
23853       {
23854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23855       };
23856     }
23857   }
23858 }
23859
23860
23861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23862   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23863   Dali::TextureSet *arg2 = 0 ;
23864
23865   arg1 = (Dali::Renderer *)jarg1;
23866   arg2 = (Dali::TextureSet *)jarg2;
23867   if (!arg2) {
23868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23869     return ;
23870   }
23871   {
23872     try {
23873       (arg1)->SetTextures(*arg2);
23874     } catch (std::out_of_range& e) {
23875       {
23876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23877       };
23878     } catch (std::exception& e) {
23879       {
23880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23881       };
23882     } catch (...) {
23883       {
23884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23885       };
23886     }
23887   }
23888 }
23889
23890
23891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23892   void * jresult ;
23893   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23894   Dali::TextureSet result;
23895
23896   arg1 = (Dali::Renderer *)jarg1;
23897   {
23898     try {
23899       result = ((Dali::Renderer const *)arg1)->GetTextures();
23900     } catch (std::out_of_range& e) {
23901       {
23902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (std::exception& e) {
23905       {
23906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23907       };
23908     } catch (...) {
23909       {
23910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23911       };
23912     }
23913   }
23914   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23915   return jresult;
23916 }
23917
23918
23919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23920   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23921   Dali::Shader *arg2 = 0 ;
23922
23923   arg1 = (Dali::Renderer *)jarg1;
23924   arg2 = (Dali::Shader *)jarg2;
23925   if (!arg2) {
23926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23927     return ;
23928   }
23929   {
23930     try {
23931       (arg1)->SetShader(*arg2);
23932     } catch (std::out_of_range& e) {
23933       {
23934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23935       };
23936     } catch (std::exception& e) {
23937       {
23938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23939       };
23940     } catch (...) {
23941       {
23942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23943       };
23944     }
23945   }
23946 }
23947
23948
23949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23950   void * jresult ;
23951   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23952   Dali::Shader result;
23953
23954   arg1 = (Dali::Renderer *)jarg1;
23955   {
23956     try {
23957       result = ((Dali::Renderer const *)arg1)->GetShader();
23958     } catch (std::out_of_range& e) {
23959       {
23960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23961       };
23962     } catch (std::exception& e) {
23963       {
23964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23965       };
23966     } catch (...) {
23967       {
23968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23969       };
23970     }
23971   }
23972   jresult = new Dali::Shader((const Dali::Shader &)result);
23973   return jresult;
23974 }
23975
23976
23977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23978   void * jresult ;
23979   Dali::FrameBuffer::Attachment *result = 0 ;
23980
23981   {
23982     try {
23983       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23984     } catch (std::out_of_range& e) {
23985       {
23986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (std::exception& e) {
23989       {
23990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23991       };
23992     } catch (...) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23995       };
23996     }
23997   }
23998   jresult = (void *)result;
23999   return jresult;
24000 }
24001
24002
24003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24004   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24005
24006   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24007   {
24008     try {
24009       delete arg1;
24010     } catch (std::out_of_range& e) {
24011       {
24012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24013       };
24014     } catch (std::exception& e) {
24015       {
24016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24017       };
24018     } catch (...) {
24019       {
24020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24021       };
24022     }
24023   }
24024 }
24025
24026
24027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24028   void * jresult ;
24029   unsigned int arg1 ;
24030   unsigned int arg2 ;
24031   unsigned int arg3 ;
24032   Dali::FrameBuffer result;
24033
24034   arg1 = (unsigned int)jarg1;
24035   arg2 = (unsigned int)jarg2;
24036   arg3 = (unsigned int)jarg3;
24037   {
24038     try {
24039       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24040     } catch (std::out_of_range& e) {
24041       {
24042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24043       };
24044     } catch (std::exception& e) {
24045       {
24046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (...) {
24049       {
24050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24051       };
24052     }
24053   }
24054   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24055   return jresult;
24056 }
24057
24058
24059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24060   void * jresult ;
24061   Dali::FrameBuffer *result = 0 ;
24062
24063   {
24064     try {
24065       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24066     } catch (std::out_of_range& e) {
24067       {
24068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (std::exception& e) {
24071       {
24072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24073       };
24074     } catch (...) {
24075       {
24076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24077       };
24078     }
24079   }
24080   jresult = (void *)result;
24081   return jresult;
24082 }
24083
24084
24085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24086   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24087
24088   arg1 = (Dali::FrameBuffer *)jarg1;
24089   {
24090     try {
24091       delete arg1;
24092     } catch (std::out_of_range& e) {
24093       {
24094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24095       };
24096     } catch (std::exception& e) {
24097       {
24098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24099       };
24100     } catch (...) {
24101       {
24102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24103       };
24104     }
24105   }
24106 }
24107
24108
24109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24110   void * jresult ;
24111   Dali::FrameBuffer *arg1 = 0 ;
24112   Dali::FrameBuffer *result = 0 ;
24113
24114   arg1 = (Dali::FrameBuffer *)jarg1;
24115   if (!arg1) {
24116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24117     return 0;
24118   }
24119   {
24120     try {
24121       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24122     } catch (std::out_of_range& e) {
24123       {
24124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (std::exception& e) {
24127       {
24128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (...) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24133       };
24134     }
24135   }
24136   jresult = (void *)result;
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24142   void * jresult ;
24143   Dali::BaseHandle arg1 ;
24144   Dali::BaseHandle *argp1 ;
24145   Dali::FrameBuffer result;
24146
24147   argp1 = (Dali::BaseHandle *)jarg1;
24148   if (!argp1) {
24149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24150     return 0;
24151   }
24152   arg1 = *argp1;
24153   {
24154     try {
24155       result = Dali::FrameBuffer::DownCast(arg1);
24156     } catch (std::out_of_range& e) {
24157       {
24158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24159       };
24160     } catch (std::exception& e) {
24161       {
24162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24163       };
24164     } catch (...) {
24165       {
24166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24167       };
24168     }
24169   }
24170   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24176   void * jresult ;
24177   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24178   Dali::FrameBuffer *arg2 = 0 ;
24179   Dali::FrameBuffer *result = 0 ;
24180
24181   arg1 = (Dali::FrameBuffer *)jarg1;
24182   arg2 = (Dali::FrameBuffer *)jarg2;
24183   if (!arg2) {
24184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24185     return 0;
24186   }
24187   {
24188     try {
24189       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24190     } catch (std::out_of_range& e) {
24191       {
24192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24193       };
24194     } catch (std::exception& e) {
24195       {
24196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24197       };
24198     } catch (...) {
24199       {
24200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24201       };
24202     }
24203   }
24204   jresult = (void *)result;
24205   return jresult;
24206 }
24207
24208
24209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24210   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24211   Dali::Texture *arg2 = 0 ;
24212
24213   arg1 = (Dali::FrameBuffer *)jarg1;
24214   arg2 = (Dali::Texture *)jarg2;
24215   if (!arg2) {
24216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24217     return ;
24218   }
24219   {
24220     try {
24221       (arg1)->AttachColorTexture(*arg2);
24222     } catch (std::out_of_range& e) {
24223       {
24224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24225       };
24226     } catch (std::exception& e) {
24227       {
24228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24229       };
24230     } catch (...) {
24231       {
24232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24233       };
24234     }
24235   }
24236 }
24237
24238
24239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24240   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24241   Dali::Texture *arg2 = 0 ;
24242   unsigned int arg3 ;
24243   unsigned int arg4 ;
24244
24245   arg1 = (Dali::FrameBuffer *)jarg1;
24246   arg2 = (Dali::Texture *)jarg2;
24247   if (!arg2) {
24248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24249     return ;
24250   }
24251   arg3 = (unsigned int)jarg3;
24252   arg4 = (unsigned int)jarg4;
24253   {
24254     try {
24255       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24256     } catch (std::out_of_range& e) {
24257       {
24258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24259       };
24260     } catch (std::exception& e) {
24261       {
24262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24263       };
24264     } catch (...) {
24265       {
24266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24267       };
24268     }
24269   }
24270 }
24271
24272
24273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24274   void * jresult ;
24275   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24276   Dali::Texture result;
24277
24278   arg1 = (Dali::FrameBuffer *)jarg1;
24279   {
24280     try {
24281       result = (arg1)->GetColorTexture();
24282     } catch (std::out_of_range& e) {
24283       {
24284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24285       };
24286     } catch (std::exception& e) {
24287       {
24288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24289       };
24290     } catch (...) {
24291       {
24292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24293       };
24294     }
24295   }
24296   jresult = new Dali::Texture((const Dali::Texture &)result);
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24302   void * jresult ;
24303   Dali::RenderTaskList *result = 0 ;
24304
24305   {
24306     try {
24307       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24308     } catch (std::out_of_range& e) {
24309       {
24310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24311       };
24312     } catch (std::exception& e) {
24313       {
24314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24315       };
24316     } catch (...) {
24317       {
24318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24319       };
24320     }
24321   }
24322   jresult = (void *)result;
24323   return jresult;
24324 }
24325
24326
24327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24328   void * jresult ;
24329   Dali::BaseHandle arg1 ;
24330   Dali::BaseHandle *argp1 ;
24331   Dali::RenderTaskList result;
24332
24333   argp1 = (Dali::BaseHandle *)jarg1;
24334   if (!argp1) {
24335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24336     return 0;
24337   }
24338   arg1 = *argp1;
24339   {
24340     try {
24341       result = Dali::RenderTaskList::DownCast(arg1);
24342     } catch (std::out_of_range& e) {
24343       {
24344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24345       };
24346     } catch (std::exception& e) {
24347       {
24348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24349       };
24350     } catch (...) {
24351       {
24352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24353       };
24354     }
24355   }
24356   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24357   return jresult;
24358 }
24359
24360
24361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24362   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24363
24364   arg1 = (Dali::RenderTaskList *)jarg1;
24365   {
24366     try {
24367       delete arg1;
24368     } catch (std::out_of_range& e) {
24369       {
24370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24371       };
24372     } catch (std::exception& e) {
24373       {
24374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24375       };
24376     } catch (...) {
24377       {
24378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24379       };
24380     }
24381   }
24382 }
24383
24384
24385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24386   void * jresult ;
24387   Dali::RenderTaskList *arg1 = 0 ;
24388   Dali::RenderTaskList *result = 0 ;
24389
24390   arg1 = (Dali::RenderTaskList *)jarg1;
24391   if (!arg1) {
24392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24393     return 0;
24394   }
24395   {
24396     try {
24397       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24398     } catch (std::out_of_range& e) {
24399       {
24400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24401       };
24402     } catch (std::exception& e) {
24403       {
24404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24405       };
24406     } catch (...) {
24407       {
24408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24409       };
24410     }
24411   }
24412   jresult = (void *)result;
24413   return jresult;
24414 }
24415
24416
24417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24418   void * jresult ;
24419   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24420   Dali::RenderTaskList *arg2 = 0 ;
24421   Dali::RenderTaskList *result = 0 ;
24422
24423   arg1 = (Dali::RenderTaskList *)jarg1;
24424   arg2 = (Dali::RenderTaskList *)jarg2;
24425   if (!arg2) {
24426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24427     return 0;
24428   }
24429   {
24430     try {
24431       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24432     } catch (std::out_of_range& e) {
24433       {
24434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24435       };
24436     } catch (std::exception& e) {
24437       {
24438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24439       };
24440     } catch (...) {
24441       {
24442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24443       };
24444     }
24445   }
24446   jresult = (void *)result;
24447   return jresult;
24448 }
24449
24450
24451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24452   void * jresult ;
24453   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24454   Dali::RenderTask result;
24455
24456   arg1 = (Dali::RenderTaskList *)jarg1;
24457   {
24458     try {
24459       result = (arg1)->CreateTask();
24460     } catch (std::out_of_range& e) {
24461       {
24462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24463       };
24464     } catch (std::exception& e) {
24465       {
24466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24467       };
24468     } catch (...) {
24469       {
24470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24471       };
24472     }
24473   }
24474   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24475   return jresult;
24476 }
24477
24478
24479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24480   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24481   Dali::RenderTask arg2 ;
24482   Dali::RenderTask *argp2 ;
24483
24484   arg1 = (Dali::RenderTaskList *)jarg1;
24485   argp2 = (Dali::RenderTask *)jarg2;
24486   if (!argp2) {
24487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24488     return ;
24489   }
24490   arg2 = *argp2;
24491   {
24492     try {
24493       (arg1)->RemoveTask(arg2);
24494     } catch (std::out_of_range& e) {
24495       {
24496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24497       };
24498     } catch (std::exception& e) {
24499       {
24500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24501       };
24502     } catch (...) {
24503       {
24504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24505       };
24506     }
24507   }
24508 }
24509
24510
24511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24512   unsigned int jresult ;
24513   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24514   unsigned int result;
24515
24516   arg1 = (Dali::RenderTaskList *)jarg1;
24517   {
24518     try {
24519       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24520     } catch (std::out_of_range& e) {
24521       {
24522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24523       };
24524     } catch (std::exception& e) {
24525       {
24526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24527       };
24528     } catch (...) {
24529       {
24530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24531       };
24532     }
24533   }
24534   jresult = result;
24535   return jresult;
24536 }
24537
24538
24539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24540   void * jresult ;
24541   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24542   unsigned int arg2 ;
24543   Dali::RenderTask result;
24544
24545   arg1 = (Dali::RenderTaskList *)jarg1;
24546   arg2 = (unsigned int)jarg2;
24547   {
24548     try {
24549       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24550     } catch (std::out_of_range& e) {
24551       {
24552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24553       };
24554     } catch (std::exception& e) {
24555       {
24556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24557       };
24558     } catch (...) {
24559       {
24560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24561       };
24562     }
24563   }
24564   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24565   return jresult;
24566 }
24567
24568
24569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24570   int jresult ;
24571   int result;
24572
24573   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24574   jresult = (int)result;
24575   return jresult;
24576 }
24577
24578
24579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24580   int jresult ;
24581   int result;
24582
24583   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24584   jresult = (int)result;
24585   return jresult;
24586 }
24587
24588
24589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24590   int jresult ;
24591   int result;
24592
24593   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24594   jresult = (int)result;
24595   return jresult;
24596 }
24597
24598
24599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24600   int jresult ;
24601   int result;
24602
24603   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24604   jresult = (int)result;
24605   return jresult;
24606 }
24607
24608
24609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24610   void * jresult ;
24611   Dali::RenderTask::Property *result = 0 ;
24612
24613   {
24614     try {
24615       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24616     } catch (std::out_of_range& e) {
24617       {
24618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24619       };
24620     } catch (std::exception& e) {
24621       {
24622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24623       };
24624     } catch (...) {
24625       {
24626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24627       };
24628     }
24629   }
24630   jresult = (void *)result;
24631   return jresult;
24632 }
24633
24634
24635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24636   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24637
24638   arg1 = (Dali::RenderTask::Property *)jarg1;
24639   {
24640     try {
24641       delete arg1;
24642     } catch (std::out_of_range& e) {
24643       {
24644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24645       };
24646     } catch (std::exception& e) {
24647       {
24648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24649       };
24650     } catch (...) {
24651       {
24652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24653       };
24654     }
24655   }
24656 }
24657
24658
24659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24660   void * jresult ;
24661   bool (*result)(Dali::Vector2 &) = 0 ;
24662
24663   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24664   jresult = (void *)result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24670   void * jresult ;
24671   bool (*result)(Dali::Vector2 &) = 0 ;
24672
24673   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24674   jresult = (void *)result;
24675   return jresult;
24676 }
24677
24678
24679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24680   unsigned int jresult ;
24681   bool result;
24682
24683   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24684   jresult = result;
24685   return jresult;
24686 }
24687
24688
24689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24690   unsigned int jresult ;
24691   bool result;
24692
24693   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24694   jresult = result;
24695   return jresult;
24696 }
24697
24698
24699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24700   void * jresult ;
24701   Dali::Vector4 *result = 0 ;
24702
24703   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24704   jresult = (void *)result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24710   unsigned int jresult ;
24711   bool result;
24712
24713   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24714   jresult = result;
24715   return jresult;
24716 }
24717
24718
24719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24720   unsigned int jresult ;
24721   bool result;
24722
24723   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24724   jresult = result;
24725   return jresult;
24726 }
24727
24728
24729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24730   unsigned int jresult ;
24731   unsigned int result;
24732
24733   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24734   jresult = result;
24735   return jresult;
24736 }
24737
24738
24739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24740   void * jresult ;
24741   Dali::RenderTask *result = 0 ;
24742
24743   {
24744     try {
24745       result = (Dali::RenderTask *)new Dali::RenderTask();
24746     } catch (std::out_of_range& e) {
24747       {
24748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24749       };
24750     } catch (std::exception& e) {
24751       {
24752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24753       };
24754     } catch (...) {
24755       {
24756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24757       };
24758     }
24759   }
24760   jresult = (void *)result;
24761   return jresult;
24762 }
24763
24764
24765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24766   void * jresult ;
24767   Dali::BaseHandle arg1 ;
24768   Dali::BaseHandle *argp1 ;
24769   Dali::RenderTask result;
24770
24771   argp1 = (Dali::BaseHandle *)jarg1;
24772   if (!argp1) {
24773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24774     return 0;
24775   }
24776   arg1 = *argp1;
24777   {
24778     try {
24779       result = Dali::RenderTask::DownCast(arg1);
24780     } catch (std::out_of_range& e) {
24781       {
24782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (std::exception& e) {
24785       {
24786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24787       };
24788     } catch (...) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24791       };
24792     }
24793   }
24794   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24795   return jresult;
24796 }
24797
24798
24799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24800   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24801
24802   arg1 = (Dali::RenderTask *)jarg1;
24803   {
24804     try {
24805       delete arg1;
24806     } catch (std::out_of_range& e) {
24807       {
24808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24809       };
24810     } catch (std::exception& e) {
24811       {
24812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (...) {
24815       {
24816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24817       };
24818     }
24819   }
24820 }
24821
24822
24823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24824   void * jresult ;
24825   Dali::RenderTask *arg1 = 0 ;
24826   Dali::RenderTask *result = 0 ;
24827
24828   arg1 = (Dali::RenderTask *)jarg1;
24829   if (!arg1) {
24830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24831     return 0;
24832   }
24833   {
24834     try {
24835       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24836     } catch (std::out_of_range& e) {
24837       {
24838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24839       };
24840     } catch (std::exception& e) {
24841       {
24842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24843       };
24844     } catch (...) {
24845       {
24846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24847       };
24848     }
24849   }
24850   jresult = (void *)result;
24851   return jresult;
24852 }
24853
24854
24855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24856   void * jresult ;
24857   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24858   Dali::RenderTask *arg2 = 0 ;
24859   Dali::RenderTask *result = 0 ;
24860
24861   arg1 = (Dali::RenderTask *)jarg1;
24862   arg2 = (Dali::RenderTask *)jarg2;
24863   if (!arg2) {
24864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24865     return 0;
24866   }
24867   {
24868     try {
24869       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24870     } catch (std::out_of_range& e) {
24871       {
24872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24873       };
24874     } catch (std::exception& e) {
24875       {
24876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24877       };
24878     } catch (...) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24881       };
24882     }
24883   }
24884   jresult = (void *)result;
24885   return jresult;
24886 }
24887
24888
24889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24890   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24891   Dali::Actor arg2 ;
24892   Dali::Actor *argp2 ;
24893
24894   arg1 = (Dali::RenderTask *)jarg1;
24895   argp2 = (Dali::Actor *)jarg2;
24896   if (!argp2) {
24897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24898     return ;
24899   }
24900   arg2 = *argp2;
24901   {
24902     try {
24903       (arg1)->SetSourceActor(arg2);
24904     } catch (std::out_of_range& e) {
24905       {
24906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24907       };
24908     } catch (std::exception& e) {
24909       {
24910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24911       };
24912     } catch (...) {
24913       {
24914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24915       };
24916     }
24917   }
24918 }
24919
24920
24921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24922   void * jresult ;
24923   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24924   Dali::Actor result;
24925
24926   arg1 = (Dali::RenderTask *)jarg1;
24927   {
24928     try {
24929       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24930     } catch (std::out_of_range& e) {
24931       {
24932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24933       };
24934     } catch (std::exception& e) {
24935       {
24936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24937       };
24938     } catch (...) {
24939       {
24940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24941       };
24942     }
24943   }
24944   jresult = new Dali::Actor((const Dali::Actor &)result);
24945   return jresult;
24946 }
24947
24948
24949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24951   bool arg2 ;
24952
24953   arg1 = (Dali::RenderTask *)jarg1;
24954   arg2 = jarg2 ? true : false;
24955   {
24956     try {
24957       (arg1)->SetExclusive(arg2);
24958     } catch (std::out_of_range& e) {
24959       {
24960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24961       };
24962     } catch (std::exception& e) {
24963       {
24964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (...) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24969       };
24970     }
24971   }
24972 }
24973
24974
24975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24976   unsigned int jresult ;
24977   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24978   bool result;
24979
24980   arg1 = (Dali::RenderTask *)jarg1;
24981   {
24982     try {
24983       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24984     } catch (std::out_of_range& e) {
24985       {
24986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24987       };
24988     } catch (std::exception& e) {
24989       {
24990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24991       };
24992     } catch (...) {
24993       {
24994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24995       };
24996     }
24997   }
24998   jresult = result;
24999   return jresult;
25000 }
25001
25002
25003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25004   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25005   bool arg2 ;
25006
25007   arg1 = (Dali::RenderTask *)jarg1;
25008   arg2 = jarg2 ? true : false;
25009   {
25010     try {
25011       (arg1)->SetInputEnabled(arg2);
25012     } catch (std::out_of_range& e) {
25013       {
25014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25015       };
25016     } catch (std::exception& e) {
25017       {
25018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25019       };
25020     } catch (...) {
25021       {
25022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25023       };
25024     }
25025   }
25026 }
25027
25028
25029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25030   unsigned int jresult ;
25031   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25032   bool result;
25033
25034   arg1 = (Dali::RenderTask *)jarg1;
25035   {
25036     try {
25037       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25038     } catch (std::out_of_range& e) {
25039       {
25040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25041       };
25042     } catch (std::exception& e) {
25043       {
25044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25045       };
25046     } catch (...) {
25047       {
25048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25049       };
25050     }
25051   }
25052   jresult = result;
25053   return jresult;
25054 }
25055
25056
25057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25058   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25059   Dali::CameraActor arg2 ;
25060   Dali::CameraActor *argp2 ;
25061
25062   arg1 = (Dali::RenderTask *)jarg1;
25063   argp2 = (Dali::CameraActor *)jarg2;
25064   if (!argp2) {
25065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25066     return ;
25067   }
25068   arg2 = *argp2;
25069   {
25070     try {
25071       (arg1)->SetCameraActor(arg2);
25072     } catch (std::out_of_range& e) {
25073       {
25074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25075       };
25076     } catch (std::exception& e) {
25077       {
25078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25079       };
25080     } catch (...) {
25081       {
25082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25083       };
25084     }
25085   }
25086 }
25087
25088
25089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25090   void * jresult ;
25091   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25092   Dali::CameraActor result;
25093
25094   arg1 = (Dali::RenderTask *)jarg1;
25095   {
25096     try {
25097       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25098     } catch (std::out_of_range& e) {
25099       {
25100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25101       };
25102     } catch (std::exception& e) {
25103       {
25104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25105       };
25106     } catch (...) {
25107       {
25108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25109       };
25110     }
25111   }
25112   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25113   return jresult;
25114 }
25115
25116
25117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25118   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25119   Dali::FrameBufferImage arg2 ;
25120   Dali::FrameBufferImage *argp2 ;
25121
25122   arg1 = (Dali::RenderTask *)jarg1;
25123   argp2 = (Dali::FrameBufferImage *)jarg2;
25124   if (!argp2) {
25125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25126     return ;
25127   }
25128   arg2 = *argp2;
25129   {
25130     try {
25131       (arg1)->SetTargetFrameBuffer(arg2);
25132     } catch (std::out_of_range& e) {
25133       {
25134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25135       };
25136     } catch (std::exception& e) {
25137       {
25138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25139       };
25140     } catch (...) {
25141       {
25142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25143       };
25144     }
25145   }
25146 }
25147
25148
25149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25150   void * jresult ;
25151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25152   Dali::FrameBufferImage result;
25153
25154   arg1 = (Dali::RenderTask *)jarg1;
25155   {
25156     try {
25157       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25158     } catch (std::out_of_range& e) {
25159       {
25160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (std::exception& e) {
25163       {
25164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (...) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25169       };
25170     }
25171   }
25172   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25179   Dali::FrameBuffer arg2 ;
25180   Dali::FrameBuffer *argp2 ;
25181
25182   arg1 = (Dali::RenderTask *)jarg1;
25183   argp2 = (Dali::FrameBuffer *)jarg2;
25184   if (!argp2) {
25185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25186     return ;
25187   }
25188   arg2 = *argp2;
25189   {
25190     try {
25191       (arg1)->SetFrameBuffer(arg2);
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25199       };
25200     } catch (...) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25203       };
25204     }
25205   }
25206 }
25207
25208
25209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25210   void * jresult ;
25211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25212   Dali::FrameBuffer result;
25213
25214   arg1 = (Dali::RenderTask *)jarg1;
25215   {
25216     try {
25217       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25218     } catch (std::out_of_range& e) {
25219       {
25220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25221       };
25222     } catch (std::exception& e) {
25223       {
25224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25225       };
25226     } catch (...) {
25227       {
25228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25229       };
25230     }
25231   }
25232   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25233   return jresult;
25234 }
25235
25236
25237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25238   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25239   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25240
25241   arg1 = (Dali::RenderTask *)jarg1;
25242   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25243   {
25244     try {
25245       (arg1)->SetScreenToFrameBufferFunction(arg2);
25246     } catch (std::out_of_range& e) {
25247       {
25248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25249       };
25250     } catch (std::exception& e) {
25251       {
25252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25253       };
25254     } catch (...) {
25255       {
25256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25257       };
25258     }
25259   }
25260 }
25261
25262
25263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25264   void * jresult ;
25265   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25266   Dali::RenderTask::ScreenToFrameBufferFunction result;
25267
25268   arg1 = (Dali::RenderTask *)jarg1;
25269   {
25270     try {
25271       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25272     } catch (std::out_of_range& e) {
25273       {
25274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25275       };
25276     } catch (std::exception& e) {
25277       {
25278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25279       };
25280     } catch (...) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25283       };
25284     }
25285   }
25286   jresult = (void *)result;
25287   return jresult;
25288 }
25289
25290
25291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25293   Dali::Actor arg2 ;
25294   Dali::Actor *argp2 ;
25295
25296   arg1 = (Dali::RenderTask *)jarg1;
25297   argp2 = (Dali::Actor *)jarg2;
25298   if (!argp2) {
25299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25300     return ;
25301   }
25302   arg2 = *argp2;
25303   {
25304     try {
25305       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25313       };
25314     } catch (...) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25317       };
25318     }
25319   }
25320 }
25321
25322
25323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25324   void * jresult ;
25325   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25326   Dali::Actor result;
25327
25328   arg1 = (Dali::RenderTask *)jarg1;
25329   {
25330     try {
25331       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25332     } catch (std::out_of_range& e) {
25333       {
25334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25335       };
25336     } catch (std::exception& e) {
25337       {
25338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (...) {
25341       {
25342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25343       };
25344     }
25345   }
25346   jresult = new Dali::Actor((const Dali::Actor &)result);
25347   return jresult;
25348 }
25349
25350
25351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25352   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25353   Dali::Vector2 arg2 ;
25354   Dali::Vector2 *argp2 ;
25355
25356   arg1 = (Dali::RenderTask *)jarg1;
25357   argp2 = (Dali::Vector2 *)jarg2;
25358   if (!argp2) {
25359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25360     return ;
25361   }
25362   arg2 = *argp2;
25363   {
25364     try {
25365       (arg1)->SetViewportPosition(arg2);
25366     } catch (std::out_of_range& e) {
25367       {
25368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25369       };
25370     } catch (std::exception& e) {
25371       {
25372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25373       };
25374     } catch (...) {
25375       {
25376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25377       };
25378     }
25379   }
25380 }
25381
25382
25383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25384   void * jresult ;
25385   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25386   Dali::Vector2 result;
25387
25388   arg1 = (Dali::RenderTask *)jarg1;
25389   {
25390     try {
25391       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25392     } catch (std::out_of_range& e) {
25393       {
25394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25395       };
25396     } catch (std::exception& e) {
25397       {
25398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25399       };
25400     } catch (...) {
25401       {
25402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25403       };
25404     }
25405   }
25406   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25407   return jresult;
25408 }
25409
25410
25411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25412   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25413   Dali::Vector2 arg2 ;
25414   Dali::Vector2 *argp2 ;
25415
25416   arg1 = (Dali::RenderTask *)jarg1;
25417   argp2 = (Dali::Vector2 *)jarg2;
25418   if (!argp2) {
25419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25420     return ;
25421   }
25422   arg2 = *argp2;
25423   {
25424     try {
25425       (arg1)->SetViewportSize(arg2);
25426     } catch (std::out_of_range& e) {
25427       {
25428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25429       };
25430     } catch (std::exception& e) {
25431       {
25432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25433       };
25434     } catch (...) {
25435       {
25436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25437       };
25438     }
25439   }
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25444   void * jresult ;
25445   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25446   Dali::Vector2 result;
25447
25448   arg1 = (Dali::RenderTask *)jarg1;
25449   {
25450     try {
25451       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25473   Dali::Viewport arg2 ;
25474   Dali::Viewport *argp2 ;
25475
25476   arg1 = (Dali::RenderTask *)jarg1;
25477   argp2 = (Dali::Viewport *)jarg2;
25478   if (!argp2) {
25479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25480     return ;
25481   }
25482   arg2 = *argp2;
25483   {
25484     try {
25485       (arg1)->SetViewport(arg2);
25486     } catch (std::out_of_range& e) {
25487       {
25488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25489       };
25490     } catch (std::exception& e) {
25491       {
25492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25493       };
25494     } catch (...) {
25495       {
25496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25497       };
25498     }
25499   }
25500 }
25501
25502
25503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25504   void * jresult ;
25505   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25506   Dali::Viewport result;
25507
25508   arg1 = (Dali::RenderTask *)jarg1;
25509   {
25510     try {
25511       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25512     } catch (std::out_of_range& e) {
25513       {
25514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25515       };
25516     } catch (std::exception& e) {
25517       {
25518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25519       };
25520     } catch (...) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25523       };
25524     }
25525   }
25526   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25527   return jresult;
25528 }
25529
25530
25531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25532   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25533   Dali::Vector4 *arg2 = 0 ;
25534
25535   arg1 = (Dali::RenderTask *)jarg1;
25536   arg2 = (Dali::Vector4 *)jarg2;
25537   if (!arg2) {
25538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25539     return ;
25540   }
25541   {
25542     try {
25543       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25544     } catch (std::out_of_range& e) {
25545       {
25546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25547       };
25548     } catch (std::exception& e) {
25549       {
25550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25551       };
25552     } catch (...) {
25553       {
25554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25555       };
25556     }
25557   }
25558 }
25559
25560
25561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25562   void * jresult ;
25563   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25564   Dali::Vector4 result;
25565
25566   arg1 = (Dali::RenderTask *)jarg1;
25567   {
25568     try {
25569       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25570     } catch (std::out_of_range& e) {
25571       {
25572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25573       };
25574     } catch (std::exception& e) {
25575       {
25576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25577       };
25578     } catch (...) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25581       };
25582     }
25583   }
25584   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25585   return jresult;
25586 }
25587
25588
25589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25590   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25591   bool arg2 ;
25592
25593   arg1 = (Dali::RenderTask *)jarg1;
25594   arg2 = jarg2 ? true : false;
25595   {
25596     try {
25597       (arg1)->SetClearEnabled(arg2);
25598     } catch (std::out_of_range& e) {
25599       {
25600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25601       };
25602     } catch (std::exception& e) {
25603       {
25604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25605       };
25606     } catch (...) {
25607       {
25608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25609       };
25610     }
25611   }
25612 }
25613
25614
25615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25616   unsigned int jresult ;
25617   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25618   bool result;
25619
25620   arg1 = (Dali::RenderTask *)jarg1;
25621   {
25622     try {
25623       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25624     } catch (std::out_of_range& e) {
25625       {
25626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (std::exception& e) {
25629       {
25630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25631       };
25632     } catch (...) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25635       };
25636     }
25637   }
25638   jresult = result;
25639   return jresult;
25640 }
25641
25642
25643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25644   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25645   bool arg2 ;
25646
25647   arg1 = (Dali::RenderTask *)jarg1;
25648   arg2 = jarg2 ? true : false;
25649   {
25650     try {
25651       (arg1)->SetCullMode(arg2);
25652     } catch (std::out_of_range& e) {
25653       {
25654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25655       };
25656     } catch (std::exception& e) {
25657       {
25658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25659       };
25660     } catch (...) {
25661       {
25662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25663       };
25664     }
25665   }
25666 }
25667
25668
25669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25670   unsigned int jresult ;
25671   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25672   bool result;
25673
25674   arg1 = (Dali::RenderTask *)jarg1;
25675   {
25676     try {
25677       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25678     } catch (std::out_of_range& e) {
25679       {
25680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25681       };
25682     } catch (std::exception& e) {
25683       {
25684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25685       };
25686     } catch (...) {
25687       {
25688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25689       };
25690     }
25691   }
25692   jresult = result;
25693   return jresult;
25694 }
25695
25696
25697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25698   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25699   unsigned int arg2 ;
25700
25701   arg1 = (Dali::RenderTask *)jarg1;
25702   arg2 = (unsigned int)jarg2;
25703   {
25704     try {
25705       (arg1)->SetRefreshRate(arg2);
25706     } catch (std::out_of_range& e) {
25707       {
25708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25709       };
25710     } catch (std::exception& e) {
25711       {
25712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25713       };
25714     } catch (...) {
25715       {
25716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25717       };
25718     }
25719   }
25720 }
25721
25722
25723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25724   unsigned int jresult ;
25725   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25726   unsigned int result;
25727
25728   arg1 = (Dali::RenderTask *)jarg1;
25729   {
25730     try {
25731       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25732     } catch (std::out_of_range& e) {
25733       {
25734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25735       };
25736     } catch (std::exception& e) {
25737       {
25738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25739       };
25740     } catch (...) {
25741       {
25742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25743       };
25744     }
25745   }
25746   jresult = result;
25747   return jresult;
25748 }
25749
25750
25751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25752   unsigned int jresult ;
25753   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25754   Dali::Vector3 *arg2 = 0 ;
25755   float *arg3 = 0 ;
25756   float *arg4 = 0 ;
25757   bool result;
25758
25759   arg1 = (Dali::RenderTask *)jarg1;
25760   arg2 = (Dali::Vector3 *)jarg2;
25761   if (!arg2) {
25762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25763     return 0;
25764   }
25765   arg3 = (float *)jarg3;
25766   arg4 = (float *)jarg4;
25767   {
25768     try {
25769       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25770     } catch (std::out_of_range& e) {
25771       {
25772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25773       };
25774     } catch (std::exception& e) {
25775       {
25776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25777       };
25778     } catch (...) {
25779       {
25780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25781       };
25782     }
25783   }
25784   jresult = result;
25785   return jresult;
25786 }
25787
25788
25789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25790   unsigned int jresult ;
25791   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25792   Dali::Actor arg2 ;
25793   float arg3 ;
25794   float arg4 ;
25795   float *arg5 = 0 ;
25796   float *arg6 = 0 ;
25797   Dali::Actor *argp2 ;
25798   bool result;
25799
25800   arg1 = (Dali::RenderTask *)jarg1;
25801   argp2 = (Dali::Actor *)jarg2;
25802   if (!argp2) {
25803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25804     return 0;
25805   }
25806   arg2 = *argp2;
25807   arg3 = (float)jarg3;
25808   arg4 = (float)jarg4;
25809   arg5 = (float *)jarg5;
25810   arg6 = (float *)jarg6;
25811   {
25812     try {
25813       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (...) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25825       };
25826     }
25827   }
25828   jresult = result;
25829   return jresult;
25830 }
25831
25832
25833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25834   void * jresult ;
25835   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25836   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25837
25838   arg1 = (Dali::RenderTask *)jarg1;
25839   {
25840     try {
25841       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25842     } catch (std::out_of_range& e) {
25843       {
25844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25845       };
25846     } catch (std::exception& e) {
25847       {
25848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25849       };
25850     } catch (...) {
25851       {
25852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25853       };
25854     }
25855   }
25856   jresult = (void *)result;
25857   return jresult;
25858 }
25859
25860
25861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25862   void * jresult ;
25863   int arg1 ;
25864   Dali::TouchPoint::State arg2 ;
25865   float arg3 ;
25866   float arg4 ;
25867   Dali::TouchPoint *result = 0 ;
25868
25869   arg1 = (int)jarg1;
25870   arg2 = (Dali::TouchPoint::State)jarg2;
25871   arg3 = (float)jarg3;
25872   arg4 = (float)jarg4;
25873   {
25874     try {
25875       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25876     } catch (std::out_of_range& e) {
25877       {
25878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25879       };
25880     } catch (std::exception& e) {
25881       {
25882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25883       };
25884     } catch (...) {
25885       {
25886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25887       };
25888     }
25889   }
25890   jresult = (void *)result;
25891   return jresult;
25892 }
25893
25894
25895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25896   void * jresult ;
25897   int arg1 ;
25898   Dali::TouchPoint::State arg2 ;
25899   float arg3 ;
25900   float arg4 ;
25901   float arg5 ;
25902   float arg6 ;
25903   Dali::TouchPoint *result = 0 ;
25904
25905   arg1 = (int)jarg1;
25906   arg2 = (Dali::TouchPoint::State)jarg2;
25907   arg3 = (float)jarg3;
25908   arg4 = (float)jarg4;
25909   arg5 = (float)jarg5;
25910   arg6 = (float)jarg6;
25911   {
25912     try {
25913       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25914     } catch (std::out_of_range& e) {
25915       {
25916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25917       };
25918     } catch (std::exception& e) {
25919       {
25920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25921       };
25922     } catch (...) {
25923       {
25924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25925       };
25926     }
25927   }
25928   jresult = (void *)result;
25929   return jresult;
25930 }
25931
25932
25933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25934   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25935
25936   arg1 = (Dali::TouchPoint *)jarg1;
25937   {
25938     try {
25939       delete arg1;
25940     } catch (std::out_of_range& e) {
25941       {
25942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25943       };
25944     } catch (std::exception& e) {
25945       {
25946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25947       };
25948     } catch (...) {
25949       {
25950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25951       };
25952     }
25953   }
25954 }
25955
25956
25957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25958   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25959   int arg2 ;
25960
25961   arg1 = (Dali::TouchPoint *)jarg1;
25962   arg2 = (int)jarg2;
25963   if (arg1) (arg1)->deviceId = arg2;
25964 }
25965
25966
25967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25968   int jresult ;
25969   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25970   int result;
25971
25972   arg1 = (Dali::TouchPoint *)jarg1;
25973   result = (int) ((arg1)->deviceId);
25974   jresult = result;
25975   return jresult;
25976 }
25977
25978
25979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25980   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25981   Dali::TouchPoint::State arg2 ;
25982
25983   arg1 = (Dali::TouchPoint *)jarg1;
25984   arg2 = (Dali::TouchPoint::State)jarg2;
25985   if (arg1) (arg1)->state = arg2;
25986 }
25987
25988
25989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25990   int jresult ;
25991   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25992   Dali::TouchPoint::State result;
25993
25994   arg1 = (Dali::TouchPoint *)jarg1;
25995   result = (Dali::TouchPoint::State) ((arg1)->state);
25996   jresult = (int)result;
25997   return jresult;
25998 }
25999
26000
26001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26002   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26003   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26004
26005   arg1 = (Dali::TouchPoint *)jarg1;
26006   arg2 = (Dali::Actor *)jarg2;
26007   if (arg1) (arg1)->hitActor = *arg2;
26008 }
26009
26010
26011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26012   void * jresult ;
26013   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26014   Dali::Actor *result = 0 ;
26015
26016   arg1 = (Dali::TouchPoint *)jarg1;
26017   result = (Dali::Actor *)& ((arg1)->hitActor);
26018   jresult = (void *)result;
26019   return jresult;
26020 }
26021
26022
26023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26024   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26025   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26026
26027   arg1 = (Dali::TouchPoint *)jarg1;
26028   arg2 = (Dali::Vector2 *)jarg2;
26029   if (arg1) (arg1)->local = *arg2;
26030 }
26031
26032
26033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26034   void * jresult ;
26035   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26036   Dali::Vector2 *result = 0 ;
26037
26038   arg1 = (Dali::TouchPoint *)jarg1;
26039   result = (Dali::Vector2 *)& ((arg1)->local);
26040   jresult = (void *)result;
26041   return jresult;
26042 }
26043
26044
26045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26046   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26047   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26048
26049   arg1 = (Dali::TouchPoint *)jarg1;
26050   arg2 = (Dali::Vector2 *)jarg2;
26051   if (arg1) (arg1)->screen = *arg2;
26052 }
26053
26054
26055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26056   void * jresult ;
26057   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26058   Dali::Vector2 *result = 0 ;
26059
26060   arg1 = (Dali::TouchPoint *)jarg1;
26061   result = (Dali::Vector2 *)& ((arg1)->screen);
26062   jresult = (void *)result;
26063   return jresult;
26064 }
26065
26066
26067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26068   void * jresult ;
26069   Dali::TouchData *result = 0 ;
26070
26071   {
26072     try {
26073       result = (Dali::TouchData *)new Dali::TouchData();
26074     } catch (std::out_of_range& e) {
26075       {
26076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26077       };
26078     } catch (std::exception& e) {
26079       {
26080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26081       };
26082     } catch (...) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26085       };
26086     }
26087   }
26088   jresult = (void *)result;
26089   return jresult;
26090 }
26091
26092
26093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26094   void * jresult ;
26095   Dali::TouchData *arg1 = 0 ;
26096   Dali::TouchData *result = 0 ;
26097
26098   arg1 = (Dali::TouchData *)jarg1;
26099   if (!arg1) {
26100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26101     return 0;
26102   }
26103   {
26104     try {
26105       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26106     } catch (std::out_of_range& e) {
26107       {
26108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26109       };
26110     } catch (std::exception& e) {
26111       {
26112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26113       };
26114     } catch (...) {
26115       {
26116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26117       };
26118     }
26119   }
26120   jresult = (void *)result;
26121   return jresult;
26122 }
26123
26124
26125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26126   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26127
26128   arg1 = (Dali::TouchData *)jarg1;
26129   {
26130     try {
26131       delete arg1;
26132     } catch (std::out_of_range& e) {
26133       {
26134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26135       };
26136     } catch (std::exception& e) {
26137       {
26138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26139       };
26140     } catch (...) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26143       };
26144     }
26145   }
26146 }
26147
26148
26149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26150   void * jresult ;
26151   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26152   Dali::TouchData *arg2 = 0 ;
26153   Dali::TouchData *result = 0 ;
26154
26155   arg1 = (Dali::TouchData *)jarg1;
26156   arg2 = (Dali::TouchData *)jarg2;
26157   if (!arg2) {
26158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26159     return 0;
26160   }
26161   {
26162     try {
26163       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26164     } catch (std::out_of_range& e) {
26165       {
26166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26167       };
26168     } catch (std::exception& e) {
26169       {
26170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26171       };
26172     } catch (...) {
26173       {
26174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26175       };
26176     }
26177   }
26178   jresult = (void *)result;
26179   return jresult;
26180 }
26181
26182
26183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26184   unsigned long jresult ;
26185   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26186   unsigned long result;
26187
26188   arg1 = (Dali::TouchData *)jarg1;
26189   {
26190     try {
26191       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26192     } catch (std::out_of_range& e) {
26193       {
26194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26195       };
26196     } catch (std::exception& e) {
26197       {
26198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26199       };
26200     } catch (...) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26203       };
26204     }
26205   }
26206   jresult = (unsigned long)result;
26207   return jresult;
26208 }
26209
26210
26211 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26212   unsigned long jresult ;
26213   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26214   std::size_t result;
26215
26216   arg1 = (Dali::TouchData *)jarg1;
26217   {
26218     try {
26219       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26220     } catch (std::out_of_range& e) {
26221       {
26222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26223       };
26224     } catch (std::exception& e) {
26225       {
26226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26227       };
26228     } catch (...) {
26229       {
26230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26231       };
26232     }
26233   }
26234   jresult = (unsigned long)result;
26235   return jresult;
26236 }
26237
26238
26239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26240   int jresult ;
26241   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26242   std::size_t arg2 ;
26243   int32_t result;
26244
26245   arg1 = (Dali::TouchData *)jarg1;
26246   arg2 = (std::size_t)jarg2;
26247   {
26248     try {
26249       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26250     } catch (std::out_of_range& e) {
26251       {
26252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26253       };
26254     } catch (std::exception& e) {
26255       {
26256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26257       };
26258     } catch (...) {
26259       {
26260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26261       };
26262     }
26263   }
26264   jresult = result;
26265   return jresult;
26266 }
26267
26268
26269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26270   int jresult ;
26271   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26272   std::size_t arg2 ;
26273   Dali::PointState::Type result;
26274
26275   arg1 = (Dali::TouchData *)jarg1;
26276   arg2 = (std::size_t)jarg2;
26277   {
26278     try {
26279       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26280     } catch (std::out_of_range& e) {
26281       {
26282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26283       };
26284     } catch (std::exception& e) {
26285       {
26286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26287       };
26288     } catch (...) {
26289       {
26290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26291       };
26292     }
26293   }
26294   jresult = (int)result;
26295   return jresult;
26296 }
26297
26298
26299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26300   void * jresult ;
26301   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26302   std::size_t arg2 ;
26303   Dali::Actor result;
26304
26305   arg1 = (Dali::TouchData *)jarg1;
26306   arg2 = (std::size_t)jarg2;
26307   {
26308     try {
26309       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26310     } catch (std::out_of_range& e) {
26311       {
26312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26313       };
26314     } catch (std::exception& e) {
26315       {
26316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26317       };
26318     } catch (...) {
26319       {
26320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26321       };
26322     }
26323   }
26324   jresult = new Dali::Actor((const Dali::Actor &)result);
26325   return jresult;
26326 }
26327
26328
26329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26330   void * jresult ;
26331   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26332   std::size_t arg2 ;
26333   Dali::Vector2 *result = 0 ;
26334
26335   arg1 = (Dali::TouchData *)jarg1;
26336   arg2 = (std::size_t)jarg2;
26337   {
26338     try {
26339       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26340     } catch (std::out_of_range& e) {
26341       {
26342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26343       };
26344     } catch (std::exception& e) {
26345       {
26346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26347       };
26348     } catch (...) {
26349       {
26350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26351       };
26352     }
26353   }
26354   jresult = (void *)result;
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26360   void * jresult ;
26361   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26362   std::size_t arg2 ;
26363   Dali::Vector2 *result = 0 ;
26364
26365   arg1 = (Dali::TouchData *)jarg1;
26366   arg2 = (std::size_t)jarg2;
26367   {
26368     try {
26369       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26370     } catch (std::out_of_range& e) {
26371       {
26372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (std::exception& e) {
26375       {
26376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384   jresult = (void *)result;
26385   return jresult;
26386 }
26387
26388
26389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26390   float jresult ;
26391   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26392   std::size_t arg2 ;
26393   float result;
26394
26395   arg1 = (Dali::TouchData *)jarg1;
26396   arg2 = (std::size_t)jarg2;
26397   {
26398     try {
26399       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26400     } catch (std::out_of_range& e) {
26401       {
26402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26403       };
26404     } catch (std::exception& e) {
26405       {
26406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26407       };
26408     } catch (...) {
26409       {
26410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26411       };
26412     }
26413   }
26414   jresult = result;
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26420   void * jresult ;
26421   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26422   std::size_t arg2 ;
26423   Dali::Vector2 *result = 0 ;
26424
26425   arg1 = (Dali::TouchData *)jarg1;
26426   arg2 = (std::size_t)jarg2;
26427   {
26428     try {
26429       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26430     } catch (std::out_of_range& e) {
26431       {
26432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26433       };
26434     } catch (std::exception& e) {
26435       {
26436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (...) {
26439       {
26440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26441       };
26442     }
26443   }
26444   jresult = (void *)result;
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26450   float jresult ;
26451   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26452   std::size_t arg2 ;
26453   float result;
26454
26455   arg1 = (Dali::TouchData *)jarg1;
26456   arg2 = (std::size_t)jarg2;
26457   {
26458     try {
26459       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26460     } catch (std::out_of_range& e) {
26461       {
26462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26463       };
26464     } catch (std::exception& e) {
26465       {
26466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26467       };
26468     } catch (...) {
26469       {
26470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26471       };
26472     }
26473   }
26474   jresult = result;
26475   return jresult;
26476 }
26477
26478
26479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26480   void * jresult ;
26481   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26482   std::size_t arg2 ;
26483   Dali::Degree result;
26484
26485   arg1 = (Dali::TouchData *)jarg1;
26486   arg2 = (std::size_t)jarg2;
26487   {
26488     try {
26489       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26490     } catch (std::out_of_range& e) {
26491       {
26492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26493       };
26494     } catch (std::exception& e) {
26495       {
26496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26497       };
26498     } catch (...) {
26499       {
26500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26501       };
26502     }
26503   }
26504   jresult = new Dali::Degree((const Dali::Degree &)result);
26505   return jresult;
26506 }
26507
26508
26509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26510   void * jresult ;
26511   Dali::GestureDetector *result = 0 ;
26512
26513   {
26514     try {
26515       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26516     } catch (std::out_of_range& e) {
26517       {
26518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26519       };
26520     } catch (std::exception& e) {
26521       {
26522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26523       };
26524     } catch (...) {
26525       {
26526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26527       };
26528     }
26529   }
26530   jresult = (void *)result;
26531   return jresult;
26532 }
26533
26534
26535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26536   void * jresult ;
26537   Dali::BaseHandle arg1 ;
26538   Dali::BaseHandle *argp1 ;
26539   Dali::GestureDetector result;
26540
26541   argp1 = (Dali::BaseHandle *)jarg1;
26542   if (!argp1) {
26543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26544     return 0;
26545   }
26546   arg1 = *argp1;
26547   {
26548     try {
26549       result = Dali::GestureDetector::DownCast(arg1);
26550     } catch (std::out_of_range& e) {
26551       {
26552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26553       };
26554     } catch (std::exception& e) {
26555       {
26556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26557       };
26558     } catch (...) {
26559       {
26560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26561       };
26562     }
26563   }
26564   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26565   return jresult;
26566 }
26567
26568
26569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26570   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26571
26572   arg1 = (Dali::GestureDetector *)jarg1;
26573   {
26574     try {
26575       delete arg1;
26576     } catch (std::out_of_range& e) {
26577       {
26578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26579       };
26580     } catch (std::exception& e) {
26581       {
26582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26583       };
26584     } catch (...) {
26585       {
26586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26587       };
26588     }
26589   }
26590 }
26591
26592
26593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26594   void * jresult ;
26595   Dali::GestureDetector *arg1 = 0 ;
26596   Dali::GestureDetector *result = 0 ;
26597
26598   arg1 = (Dali::GestureDetector *)jarg1;
26599   if (!arg1) {
26600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26601     return 0;
26602   }
26603   {
26604     try {
26605       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26606     } catch (std::out_of_range& e) {
26607       {
26608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26609       };
26610     } catch (std::exception& e) {
26611       {
26612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26613       };
26614     } catch (...) {
26615       {
26616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26617       };
26618     }
26619   }
26620   jresult = (void *)result;
26621   return jresult;
26622 }
26623
26624
26625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26626   void * jresult ;
26627   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26628   Dali::GestureDetector *arg2 = 0 ;
26629   Dali::GestureDetector *result = 0 ;
26630
26631   arg1 = (Dali::GestureDetector *)jarg1;
26632   arg2 = (Dali::GestureDetector *)jarg2;
26633   if (!arg2) {
26634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26635     return 0;
26636   }
26637   {
26638     try {
26639       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26640     } catch (std::out_of_range& e) {
26641       {
26642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26643       };
26644     } catch (std::exception& e) {
26645       {
26646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26647       };
26648     } catch (...) {
26649       {
26650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26651       };
26652     }
26653   }
26654   jresult = (void *)result;
26655   return jresult;
26656 }
26657
26658
26659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26660   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26661   Dali::Actor arg2 ;
26662   Dali::Actor *argp2 ;
26663
26664   arg1 = (Dali::GestureDetector *)jarg1;
26665   argp2 = (Dali::Actor *)jarg2;
26666   if (!argp2) {
26667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26668     return ;
26669   }
26670   arg2 = *argp2;
26671   {
26672     try {
26673       (arg1)->Attach(arg2);
26674     } catch (std::out_of_range& e) {
26675       {
26676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26677       };
26678     } catch (std::exception& e) {
26679       {
26680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26681       };
26682     } catch (...) {
26683       {
26684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26685       };
26686     }
26687   }
26688 }
26689
26690
26691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26692   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26693   Dali::Actor arg2 ;
26694   Dali::Actor *argp2 ;
26695
26696   arg1 = (Dali::GestureDetector *)jarg1;
26697   argp2 = (Dali::Actor *)jarg2;
26698   if (!argp2) {
26699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26700     return ;
26701   }
26702   arg2 = *argp2;
26703   {
26704     try {
26705       (arg1)->Detach(arg2);
26706     } catch (std::out_of_range& e) {
26707       {
26708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26709       };
26710     } catch (std::exception& e) {
26711       {
26712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26713       };
26714     } catch (...) {
26715       {
26716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26717       };
26718     }
26719   }
26720 }
26721
26722
26723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26724   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26725
26726   arg1 = (Dali::GestureDetector *)jarg1;
26727   {
26728     try {
26729       (arg1)->DetachAll();
26730     } catch (std::out_of_range& e) {
26731       {
26732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26733       };
26734     } catch (std::exception& e) {
26735       {
26736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26737       };
26738     } catch (...) {
26739       {
26740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26741       };
26742     }
26743   }
26744 }
26745
26746
26747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26748   unsigned long jresult ;
26749   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26750   size_t result;
26751
26752   arg1 = (Dali::GestureDetector *)jarg1;
26753   {
26754     try {
26755       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26756     } catch (std::out_of_range& e) {
26757       {
26758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26759       };
26760     } catch (std::exception& e) {
26761       {
26762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26763       };
26764     } catch (...) {
26765       {
26766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26767       };
26768     }
26769   }
26770   jresult = (unsigned long)result;
26771   return jresult;
26772 }
26773
26774
26775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26776   void * jresult ;
26777   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26778   size_t arg2 ;
26779   Dali::Actor result;
26780
26781   arg1 = (Dali::GestureDetector *)jarg1;
26782   arg2 = (size_t)jarg2;
26783   {
26784     try {
26785       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26786     } catch (std::out_of_range& e) {
26787       {
26788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26789       };
26790     } catch (std::exception& e) {
26791       {
26792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26793       };
26794     } catch (...) {
26795       {
26796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26797       };
26798     }
26799   }
26800   jresult = new Dali::Actor((const Dali::Actor &)result);
26801   return jresult;
26802 }
26803
26804
26805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26806   void * jresult ;
26807   Dali::Gesture *arg1 = 0 ;
26808   Dali::Gesture *result = 0 ;
26809
26810   arg1 = (Dali::Gesture *)jarg1;
26811   if (!arg1) {
26812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26813     return 0;
26814   }
26815   {
26816     try {
26817       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26818     } catch (std::out_of_range& e) {
26819       {
26820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26821       };
26822     } catch (std::exception& e) {
26823       {
26824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26825       };
26826     } catch (...) {
26827       {
26828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26829       };
26830     }
26831   }
26832   jresult = (void *)result;
26833   return jresult;
26834 }
26835
26836
26837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26838   void * jresult ;
26839   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26840   Dali::Gesture *arg2 = 0 ;
26841   Dali::Gesture *result = 0 ;
26842
26843   arg1 = (Dali::Gesture *)jarg1;
26844   arg2 = (Dali::Gesture *)jarg2;
26845   if (!arg2) {
26846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26847     return 0;
26848   }
26849   {
26850     try {
26851       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26852     } catch (std::out_of_range& e) {
26853       {
26854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26855       };
26856     } catch (std::exception& e) {
26857       {
26858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26859       };
26860     } catch (...) {
26861       {
26862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26863       };
26864     }
26865   }
26866   jresult = (void *)result;
26867   return jresult;
26868 }
26869
26870
26871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26872   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26873
26874   arg1 = (Dali::Gesture *)jarg1;
26875   {
26876     try {
26877       delete arg1;
26878     } catch (std::out_of_range& e) {
26879       {
26880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26881       };
26882     } catch (std::exception& e) {
26883       {
26884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26885       };
26886     } catch (...) {
26887       {
26888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26889       };
26890     }
26891   }
26892 }
26893
26894
26895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26896   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26897   Dali::Gesture::Type arg2 ;
26898
26899   arg1 = (Dali::Gesture *)jarg1;
26900   arg2 = (Dali::Gesture::Type)jarg2;
26901   if (arg1) (arg1)->type = arg2;
26902 }
26903
26904
26905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26906   int jresult ;
26907   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26908   Dali::Gesture::Type result;
26909
26910   arg1 = (Dali::Gesture *)jarg1;
26911   result = (Dali::Gesture::Type) ((arg1)->type);
26912   jresult = (int)result;
26913   return jresult;
26914 }
26915
26916
26917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26918   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26919   Dali::Gesture::State arg2 ;
26920
26921   arg1 = (Dali::Gesture *)jarg1;
26922   arg2 = (Dali::Gesture::State)jarg2;
26923   if (arg1) (arg1)->state = arg2;
26924 }
26925
26926
26927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26928   int jresult ;
26929   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26930   Dali::Gesture::State result;
26931
26932   arg1 = (Dali::Gesture *)jarg1;
26933   result = (Dali::Gesture::State) ((arg1)->state);
26934   jresult = (int)result;
26935   return jresult;
26936 }
26937
26938
26939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26940   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26941   unsigned int arg2 ;
26942
26943   arg1 = (Dali::Gesture *)jarg1;
26944   arg2 = (unsigned int)jarg2;
26945   if (arg1) (arg1)->time = arg2;
26946 }
26947
26948
26949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26950   unsigned int jresult ;
26951   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26952   unsigned int result;
26953
26954   arg1 = (Dali::Gesture *)jarg1;
26955   result = (unsigned int) ((arg1)->time);
26956   jresult = result;
26957   return jresult;
26958 }
26959
26960
26961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26962   void * jresult ;
26963   Dali::HoverEvent *result = 0 ;
26964
26965   {
26966     try {
26967       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26968     } catch (std::out_of_range& e) {
26969       {
26970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26971       };
26972     } catch (std::exception& e) {
26973       {
26974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26975       };
26976     } catch (...) {
26977       {
26978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26979       };
26980     }
26981   }
26982   jresult = (void *)result;
26983   return jresult;
26984 }
26985
26986
26987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26988   void * jresult ;
26989   unsigned long arg1 ;
26990   Dali::HoverEvent *result = 0 ;
26991
26992   arg1 = (unsigned long)jarg1;
26993   {
26994     try {
26995       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26996     } catch (std::out_of_range& e) {
26997       {
26998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26999       };
27000     } catch (std::exception& e) {
27001       {
27002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27003       };
27004     } catch (...) {
27005       {
27006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27007       };
27008     }
27009   }
27010   jresult = (void *)result;
27011   return jresult;
27012 }
27013
27014
27015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27016   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27017
27018   arg1 = (Dali::HoverEvent *)jarg1;
27019   {
27020     try {
27021       delete arg1;
27022     } catch (std::out_of_range& e) {
27023       {
27024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27025       };
27026     } catch (std::exception& e) {
27027       {
27028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27029       };
27030     } catch (...) {
27031       {
27032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27033       };
27034     }
27035   }
27036 }
27037
27038
27039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27040   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27041   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27042
27043   arg1 = (Dali::HoverEvent *)jarg1;
27044   arg2 = (Dali::TouchPointContainer *)jarg2;
27045   if (arg1) (arg1)->points = *arg2;
27046 }
27047
27048
27049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27050   void * jresult ;
27051   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27052   Dali::TouchPointContainer *result = 0 ;
27053
27054   arg1 = (Dali::HoverEvent *)jarg1;
27055   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27056   jresult = (void *)result;
27057   return jresult;
27058 }
27059
27060
27061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27062   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27063   unsigned long arg2 ;
27064
27065   arg1 = (Dali::HoverEvent *)jarg1;
27066   arg2 = (unsigned long)jarg2;
27067   if (arg1) (arg1)->time = arg2;
27068 }
27069
27070
27071 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27072   unsigned long jresult ;
27073   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27074   unsigned long result;
27075
27076   arg1 = (Dali::HoverEvent *)jarg1;
27077   result = (unsigned long) ((arg1)->time);
27078   jresult = (unsigned long)result;
27079   return jresult;
27080 }
27081
27082
27083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27084   unsigned int jresult ;
27085   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27086   unsigned int result;
27087
27088   arg1 = (Dali::HoverEvent *)jarg1;
27089   {
27090     try {
27091       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (...) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27103       };
27104     }
27105   }
27106   jresult = result;
27107   return jresult;
27108 }
27109
27110
27111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27112   void * jresult ;
27113   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27114   unsigned int arg2 ;
27115   Dali::TouchPoint *result = 0 ;
27116
27117   arg1 = (Dali::HoverEvent *)jarg1;
27118   arg2 = (unsigned int)jarg2;
27119   {
27120     try {
27121       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27122     } catch (std::out_of_range& e) {
27123       {
27124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27125       };
27126     } catch (std::exception& e) {
27127       {
27128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27129       };
27130     } catch (...) {
27131       {
27132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27133       };
27134     }
27135   }
27136   jresult = (void *)result;
27137   return jresult;
27138 }
27139
27140
27141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27142   void * jresult ;
27143   Dali::KeyEvent *result = 0 ;
27144
27145   {
27146     try {
27147       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27148     } catch (std::out_of_range& e) {
27149       {
27150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27151       };
27152     } catch (std::exception& e) {
27153       {
27154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27155       };
27156     } catch (...) {
27157       {
27158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27159       };
27160     }
27161   }
27162   jresult = (void *)result;
27163   return jresult;
27164 }
27165
27166
27167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27168   void * jresult ;
27169   std::string *arg1 = 0 ;
27170   std::string *arg2 = 0 ;
27171   int arg3 ;
27172   int arg4 ;
27173   unsigned long arg5 ;
27174   Dali::KeyEvent::State *arg6 = 0 ;
27175   Dali::KeyEvent::State temp6 ;
27176   Dali::KeyEvent *result = 0 ;
27177
27178   if (!jarg1) {
27179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27180     return 0;
27181   }
27182   std::string arg1_str(jarg1);
27183   arg1 = &arg1_str;
27184   if (!jarg2) {
27185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27186     return 0;
27187   }
27188   std::string arg2_str(jarg2);
27189   arg2 = &arg2_str;
27190   arg3 = (int)jarg3;
27191   arg4 = (int)jarg4;
27192   arg5 = (unsigned long)jarg5;
27193   temp6 = (Dali::KeyEvent::State)jarg6;
27194   arg6 = &temp6;
27195   {
27196     try {
27197       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27198     } catch (std::out_of_range& e) {
27199       {
27200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27201       };
27202     } catch (std::exception& e) {
27203       {
27204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27205       };
27206     } catch (...) {
27207       {
27208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27209       };
27210     }
27211   }
27212   jresult = (void *)result;
27213
27214   //argout typemap for const std::string&
27215
27216
27217   //argout typemap for const std::string&
27218
27219   return jresult;
27220 }
27221
27222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27223   void * jresult ;
27224   Dali::KeyEvent *arg1 = 0 ;
27225   Dali::KeyEvent *result = 0 ;
27226
27227   arg1 = (Dali::KeyEvent *)jarg1;
27228   if (!arg1) {
27229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27230     return 0;
27231   }
27232   {
27233     try {
27234       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27235     } catch (std::out_of_range& e) {
27236       {
27237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27238       };
27239     } catch (std::exception& e) {
27240       {
27241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27242       };
27243     } catch (...) {
27244       {
27245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27246       };
27247     }
27248   }
27249   jresult = (void *)result;
27250   return jresult;
27251 }
27252
27253
27254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27255   void * jresult ;
27256   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27257   Dali::KeyEvent *arg2 = 0 ;
27258   Dali::KeyEvent *result = 0 ;
27259
27260   arg1 = (Dali::KeyEvent *)jarg1;
27261   arg2 = (Dali::KeyEvent *)jarg2;
27262   if (!arg2) {
27263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27264     return 0;
27265   }
27266   {
27267     try {
27268       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27269     } catch (std::out_of_range& e) {
27270       {
27271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27272       };
27273     } catch (std::exception& e) {
27274       {
27275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27276       };
27277     } catch (...) {
27278       {
27279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27280       };
27281     }
27282   }
27283   jresult = (void *)result;
27284   return jresult;
27285 }
27286
27287
27288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27289   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27290
27291   arg1 = (Dali::KeyEvent *)jarg1;
27292   {
27293     try {
27294       delete arg1;
27295     } catch (std::out_of_range& e) {
27296       {
27297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27298       };
27299     } catch (std::exception& e) {
27300       {
27301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27302       };
27303     } catch (...) {
27304       {
27305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27306       };
27307     }
27308   }
27309 }
27310
27311
27312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27313   unsigned int jresult ;
27314   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27315   bool result;
27316
27317   arg1 = (Dali::KeyEvent *)jarg1;
27318   {
27319     try {
27320       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27321     } catch (std::out_of_range& e) {
27322       {
27323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27324       };
27325     } catch (std::exception& e) {
27326       {
27327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27328       };
27329     } catch (...) {
27330       {
27331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27332       };
27333     }
27334   }
27335   jresult = result;
27336   return jresult;
27337 }
27338
27339
27340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27341   unsigned int jresult ;
27342   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27343   bool result;
27344
27345   arg1 = (Dali::KeyEvent *)jarg1;
27346   {
27347     try {
27348       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27349     } catch (std::out_of_range& e) {
27350       {
27351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27352       };
27353     } catch (std::exception& e) {
27354       {
27355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27356       };
27357     } catch (...) {
27358       {
27359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27360       };
27361     }
27362   }
27363   jresult = result;
27364   return jresult;
27365 }
27366
27367
27368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27369   unsigned int jresult ;
27370   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27371   bool result;
27372
27373   arg1 = (Dali::KeyEvent *)jarg1;
27374   {
27375     try {
27376       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27377     } catch (std::out_of_range& e) {
27378       {
27379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27380       };
27381     } catch (std::exception& e) {
27382       {
27383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27384       };
27385     } catch (...) {
27386       {
27387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27388       };
27389     }
27390   }
27391   jresult = result;
27392   return jresult;
27393 }
27394
27395
27396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27398   std::string *arg2 = 0 ;
27399
27400   arg1 = (Dali::KeyEvent *)jarg1;
27401   if (!jarg2) {
27402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27403     return ;
27404   }
27405   std::string arg2_str(jarg2);
27406   arg2 = &arg2_str;
27407   if (arg1) (arg1)->keyPressedName = *arg2;
27408
27409   //argout typemap for const std::string&
27410
27411 }
27412
27413
27414 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27415   char * jresult ;
27416   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27417   std::string *result = 0 ;
27418
27419   arg1 = (Dali::KeyEvent *)jarg1;
27420   result = (std::string *) & ((arg1)->keyPressedName);
27421   jresult = SWIG_csharp_string_callback(result->c_str());
27422   return jresult;
27423 }
27424
27425
27426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27428   std::string *arg2 = 0 ;
27429
27430   arg1 = (Dali::KeyEvent *)jarg1;
27431   if (!jarg2) {
27432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27433     return ;
27434   }
27435   std::string arg2_str(jarg2);
27436   arg2 = &arg2_str;
27437   if (arg1) (arg1)->keyPressed = *arg2;
27438
27439   //argout typemap for const std::string&
27440
27441 }
27442
27443
27444 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27445   char * jresult ;
27446   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27447   std::string *result = 0 ;
27448
27449   arg1 = (Dali::KeyEvent *)jarg1;
27450   result = (std::string *) & ((arg1)->keyPressed);
27451   jresult = SWIG_csharp_string_callback(result->c_str());
27452   return jresult;
27453 }
27454
27455
27456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27457   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27458   int arg2 ;
27459
27460   arg1 = (Dali::KeyEvent *)jarg1;
27461   arg2 = (int)jarg2;
27462   if (arg1) (arg1)->keyCode = arg2;
27463 }
27464
27465
27466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27467   int jresult ;
27468   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27469   int result;
27470
27471   arg1 = (Dali::KeyEvent *)jarg1;
27472   result = (int) ((arg1)->keyCode);
27473   jresult = result;
27474   return jresult;
27475 }
27476
27477
27478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27479   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27480   int arg2 ;
27481
27482   arg1 = (Dali::KeyEvent *)jarg1;
27483   arg2 = (int)jarg2;
27484   if (arg1) (arg1)->keyModifier = arg2;
27485 }
27486
27487
27488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27489   int jresult ;
27490   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27491   int result;
27492
27493   arg1 = (Dali::KeyEvent *)jarg1;
27494   result = (int) ((arg1)->keyModifier);
27495   jresult = result;
27496   return jresult;
27497 }
27498
27499
27500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27501   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27502   unsigned long arg2 ;
27503
27504   arg1 = (Dali::KeyEvent *)jarg1;
27505   arg2 = (unsigned long)jarg2;
27506   if (arg1) (arg1)->time = arg2;
27507 }
27508
27509
27510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27511   unsigned long jresult ;
27512   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27513   unsigned long result;
27514
27515   arg1 = (Dali::KeyEvent *)jarg1;
27516   result = (unsigned long) ((arg1)->time);
27517   jresult = (unsigned long)result;
27518   return jresult;
27519 }
27520
27521
27522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27523   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27524   Dali::KeyEvent::State arg2 ;
27525
27526   arg1 = (Dali::KeyEvent *)jarg1;
27527   arg2 = (Dali::KeyEvent::State)jarg2;
27528   if (arg1) (arg1)->state = arg2;
27529 }
27530
27531
27532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27533   int jresult ;
27534   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27535   Dali::KeyEvent::State result;
27536
27537   arg1 = (Dali::KeyEvent *)jarg1;
27538   result = (Dali::KeyEvent::State) ((arg1)->state);
27539   jresult = (int)result;
27540   return jresult;
27541 }
27542
27543
27544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27545   void * jresult ;
27546   Dali::LongPressGestureDetector *result = 0 ;
27547
27548   {
27549     try {
27550       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27551     } catch (std::out_of_range& e) {
27552       {
27553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27554       };
27555     } catch (std::exception& e) {
27556       {
27557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27558       };
27559     } catch (...) {
27560       {
27561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27562       };
27563     }
27564   }
27565   jresult = (void *)result;
27566   return jresult;
27567 }
27568
27569
27570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27571   void * jresult ;
27572   Dali::LongPressGestureDetector result;
27573
27574   {
27575     try {
27576       result = Dali::LongPressGestureDetector::New();
27577     } catch (std::out_of_range& e) {
27578       {
27579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27580       };
27581     } catch (std::exception& e) {
27582       {
27583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27584       };
27585     } catch (...) {
27586       {
27587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27588       };
27589     }
27590   }
27591   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27592   return jresult;
27593 }
27594
27595
27596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27597   void * jresult ;
27598   unsigned int arg1 ;
27599   Dali::LongPressGestureDetector result;
27600
27601   arg1 = (unsigned int)jarg1;
27602   {
27603     try {
27604       result = Dali::LongPressGestureDetector::New(arg1);
27605     } catch (std::out_of_range& e) {
27606       {
27607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27608       };
27609     } catch (std::exception& e) {
27610       {
27611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27612       };
27613     } catch (...) {
27614       {
27615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27616       };
27617     }
27618   }
27619   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27620   return jresult;
27621 }
27622
27623
27624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27625   void * jresult ;
27626   unsigned int arg1 ;
27627   unsigned int arg2 ;
27628   Dali::LongPressGestureDetector result;
27629
27630   arg1 = (unsigned int)jarg1;
27631   arg2 = (unsigned int)jarg2;
27632   {
27633     try {
27634       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27635     } catch (std::out_of_range& e) {
27636       {
27637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27638       };
27639     } catch (std::exception& e) {
27640       {
27641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27642       };
27643     } catch (...) {
27644       {
27645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27646       };
27647     }
27648   }
27649   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27650   return jresult;
27651 }
27652
27653
27654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27655   void * jresult ;
27656   Dali::BaseHandle arg1 ;
27657   Dali::BaseHandle *argp1 ;
27658   Dali::LongPressGestureDetector result;
27659
27660   argp1 = (Dali::BaseHandle *)jarg1;
27661   if (!argp1) {
27662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27663     return 0;
27664   }
27665   arg1 = *argp1;
27666   {
27667     try {
27668       result = Dali::LongPressGestureDetector::DownCast(arg1);
27669     } catch (std::out_of_range& e) {
27670       {
27671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27672       };
27673     } catch (std::exception& e) {
27674       {
27675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27676       };
27677     } catch (...) {
27678       {
27679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27680       };
27681     }
27682   }
27683   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27684   return jresult;
27685 }
27686
27687
27688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27689   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27690
27691   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27692   {
27693     try {
27694       delete arg1;
27695     } catch (std::out_of_range& e) {
27696       {
27697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27698       };
27699     } catch (std::exception& e) {
27700       {
27701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27702       };
27703     } catch (...) {
27704       {
27705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27706       };
27707     }
27708   }
27709 }
27710
27711
27712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27713   void * jresult ;
27714   Dali::LongPressGestureDetector *arg1 = 0 ;
27715   Dali::LongPressGestureDetector *result = 0 ;
27716
27717   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27718   if (!arg1) {
27719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27720     return 0;
27721   }
27722   {
27723     try {
27724       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27725     } catch (std::out_of_range& e) {
27726       {
27727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27728       };
27729     } catch (std::exception& e) {
27730       {
27731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (...) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27736       };
27737     }
27738   }
27739   jresult = (void *)result;
27740   return jresult;
27741 }
27742
27743
27744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27745   void * jresult ;
27746   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27747   Dali::LongPressGestureDetector *arg2 = 0 ;
27748   Dali::LongPressGestureDetector *result = 0 ;
27749
27750   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27751   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27752   if (!arg2) {
27753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27754     return 0;
27755   }
27756   {
27757     try {
27758       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27759     } catch (std::out_of_range& e) {
27760       {
27761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27762       };
27763     } catch (std::exception& e) {
27764       {
27765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27766       };
27767     } catch (...) {
27768       {
27769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27770       };
27771     }
27772   }
27773   jresult = (void *)result;
27774   return jresult;
27775 }
27776
27777
27778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27779   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27780   unsigned int arg2 ;
27781
27782   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27783   arg2 = (unsigned int)jarg2;
27784   {
27785     try {
27786       (arg1)->SetTouchesRequired(arg2);
27787     } catch (std::out_of_range& e) {
27788       {
27789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27790       };
27791     } catch (std::exception& e) {
27792       {
27793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27794       };
27795     } catch (...) {
27796       {
27797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27798       };
27799     }
27800   }
27801 }
27802
27803
27804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27805   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27806   unsigned int arg2 ;
27807   unsigned int arg3 ;
27808
27809   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27810   arg2 = (unsigned int)jarg2;
27811   arg3 = (unsigned int)jarg3;
27812   {
27813     try {
27814       (arg1)->SetTouchesRequired(arg2,arg3);
27815     } catch (std::out_of_range& e) {
27816       {
27817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27818       };
27819     } catch (std::exception& e) {
27820       {
27821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27822       };
27823     } catch (...) {
27824       {
27825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27826       };
27827     }
27828   }
27829 }
27830
27831
27832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27833   unsigned int jresult ;
27834   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27835   unsigned int result;
27836
27837   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27838   {
27839     try {
27840       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27841     } catch (std::out_of_range& e) {
27842       {
27843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27844       };
27845     } catch (std::exception& e) {
27846       {
27847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27848       };
27849     } catch (...) {
27850       {
27851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27852       };
27853     }
27854   }
27855   jresult = result;
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27861   unsigned int jresult ;
27862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27863   unsigned int result;
27864
27865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27866   {
27867     try {
27868       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27869     } catch (std::out_of_range& e) {
27870       {
27871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27872       };
27873     } catch (std::exception& e) {
27874       {
27875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27876       };
27877     } catch (...) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27880       };
27881     }
27882   }
27883   jresult = result;
27884   return jresult;
27885 }
27886
27887
27888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27889   void * jresult ;
27890   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27891   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27892
27893   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27894   {
27895     try {
27896       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27897     } catch (std::out_of_range& e) {
27898       {
27899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27900       };
27901     } catch (std::exception& e) {
27902       {
27903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27904       };
27905     } catch (...) {
27906       {
27907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27908       };
27909     }
27910   }
27911   jresult = (void *)result;
27912   return jresult;
27913 }
27914
27915
27916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27917   void * jresult ;
27918   Dali::Gesture::State arg1 ;
27919   Dali::LongPressGesture *result = 0 ;
27920
27921   arg1 = (Dali::Gesture::State)jarg1;
27922   {
27923     try {
27924       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27925     } catch (std::out_of_range& e) {
27926       {
27927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27928       };
27929     } catch (std::exception& e) {
27930       {
27931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27932       };
27933     } catch (...) {
27934       {
27935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27936       };
27937     }
27938   }
27939   jresult = (void *)result;
27940   return jresult;
27941 }
27942
27943
27944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27945   void * jresult ;
27946   Dali::LongPressGesture *arg1 = 0 ;
27947   Dali::LongPressGesture *result = 0 ;
27948
27949   arg1 = (Dali::LongPressGesture *)jarg1;
27950   if (!arg1) {
27951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27952     return 0;
27953   }
27954   {
27955     try {
27956       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (...) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27968       };
27969     }
27970   }
27971   jresult = (void *)result;
27972   return jresult;
27973 }
27974
27975
27976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27977   void * jresult ;
27978   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27979   Dali::LongPressGesture *arg2 = 0 ;
27980   Dali::LongPressGesture *result = 0 ;
27981
27982   arg1 = (Dali::LongPressGesture *)jarg1;
27983   arg2 = (Dali::LongPressGesture *)jarg2;
27984   if (!arg2) {
27985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27986     return 0;
27987   }
27988   {
27989     try {
27990       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27991     } catch (std::out_of_range& e) {
27992       {
27993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27994       };
27995     } catch (std::exception& e) {
27996       {
27997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27998       };
27999     } catch (...) {
28000       {
28001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28002       };
28003     }
28004   }
28005   jresult = (void *)result;
28006   return jresult;
28007 }
28008
28009
28010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28011   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28012
28013   arg1 = (Dali::LongPressGesture *)jarg1;
28014   {
28015     try {
28016       delete arg1;
28017     } catch (std::out_of_range& e) {
28018       {
28019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28020       };
28021     } catch (std::exception& e) {
28022       {
28023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28024       };
28025     } catch (...) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28028       };
28029     }
28030   }
28031 }
28032
28033
28034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28035   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28036   unsigned int arg2 ;
28037
28038   arg1 = (Dali::LongPressGesture *)jarg1;
28039   arg2 = (unsigned int)jarg2;
28040   if (arg1) (arg1)->numberOfTouches = arg2;
28041 }
28042
28043
28044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28045   unsigned int jresult ;
28046   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28047   unsigned int result;
28048
28049   arg1 = (Dali::LongPressGesture *)jarg1;
28050   result = (unsigned int) ((arg1)->numberOfTouches);
28051   jresult = result;
28052   return jresult;
28053 }
28054
28055
28056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28057   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28058   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28059
28060   arg1 = (Dali::LongPressGesture *)jarg1;
28061   arg2 = (Dali::Vector2 *)jarg2;
28062   if (arg1) (arg1)->screenPoint = *arg2;
28063 }
28064
28065
28066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28067   void * jresult ;
28068   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28069   Dali::Vector2 *result = 0 ;
28070
28071   arg1 = (Dali::LongPressGesture *)jarg1;
28072   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28073   jresult = (void *)result;
28074   return jresult;
28075 }
28076
28077
28078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28079   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28080   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28081
28082   arg1 = (Dali::LongPressGesture *)jarg1;
28083   arg2 = (Dali::Vector2 *)jarg2;
28084   if (arg1) (arg1)->localPoint = *arg2;
28085 }
28086
28087
28088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28089   void * jresult ;
28090   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28091   Dali::Vector2 *result = 0 ;
28092
28093   arg1 = (Dali::LongPressGesture *)jarg1;
28094   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28095   jresult = (void *)result;
28096   return jresult;
28097 }
28098
28099
28100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28101   void * jresult ;
28102   Dali::WheelEvent *result = 0 ;
28103
28104   {
28105     try {
28106       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28107     } catch (std::out_of_range& e) {
28108       {
28109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28110       };
28111     } catch (std::exception& e) {
28112       {
28113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28114       };
28115     } catch (...) {
28116       {
28117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28118       };
28119     }
28120   }
28121   jresult = (void *)result;
28122   return jresult;
28123 }
28124
28125
28126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28127   void * jresult ;
28128   Dali::WheelEvent::Type arg1 ;
28129   int arg2 ;
28130   unsigned int arg3 ;
28131   Dali::Vector2 arg4 ;
28132   int arg5 ;
28133   unsigned int arg6 ;
28134   Dali::Vector2 *argp4 ;
28135   Dali::WheelEvent *result = 0 ;
28136
28137   arg1 = (Dali::WheelEvent::Type)jarg1;
28138   arg2 = (int)jarg2;
28139   arg3 = (unsigned int)jarg3;
28140   argp4 = (Dali::Vector2 *)jarg4;
28141   if (!argp4) {
28142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28143     return 0;
28144   }
28145   arg4 = *argp4;
28146   arg5 = (int)jarg5;
28147   arg6 = (unsigned int)jarg6;
28148   {
28149     try {
28150       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28151     } catch (std::out_of_range& e) {
28152       {
28153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28154       };
28155     } catch (std::exception& e) {
28156       {
28157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28158       };
28159     } catch (...) {
28160       {
28161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28162       };
28163     }
28164   }
28165   jresult = (void *)result;
28166   return jresult;
28167 }
28168
28169
28170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28171   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28172
28173   arg1 = (Dali::WheelEvent *)jarg1;
28174   {
28175     try {
28176       delete arg1;
28177     } catch (std::out_of_range& e) {
28178       {
28179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28180       };
28181     } catch (std::exception& e) {
28182       {
28183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28184       };
28185     } catch (...) {
28186       {
28187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28188       };
28189     }
28190   }
28191 }
28192
28193
28194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28195   unsigned int jresult ;
28196   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28197   bool result;
28198
28199   arg1 = (Dali::WheelEvent *)jarg1;
28200   {
28201     try {
28202       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28203     } catch (std::out_of_range& e) {
28204       {
28205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28206       };
28207     } catch (std::exception& e) {
28208       {
28209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28210       };
28211     } catch (...) {
28212       {
28213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28214       };
28215     }
28216   }
28217   jresult = result;
28218   return jresult;
28219 }
28220
28221
28222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28223   unsigned int jresult ;
28224   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28225   bool result;
28226
28227   arg1 = (Dali::WheelEvent *)jarg1;
28228   {
28229     try {
28230       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28231     } catch (std::out_of_range& e) {
28232       {
28233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28234       };
28235     } catch (std::exception& e) {
28236       {
28237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28238       };
28239     } catch (...) {
28240       {
28241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28242       };
28243     }
28244   }
28245   jresult = result;
28246   return jresult;
28247 }
28248
28249
28250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28251   unsigned int jresult ;
28252   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28253   bool result;
28254
28255   arg1 = (Dali::WheelEvent *)jarg1;
28256   {
28257     try {
28258       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28259     } catch (std::out_of_range& e) {
28260       {
28261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28262       };
28263     } catch (std::exception& e) {
28264       {
28265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28266       };
28267     } catch (...) {
28268       {
28269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28270       };
28271     }
28272   }
28273   jresult = result;
28274   return jresult;
28275 }
28276
28277
28278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28279   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28280   Dali::WheelEvent::Type arg2 ;
28281
28282   arg1 = (Dali::WheelEvent *)jarg1;
28283   arg2 = (Dali::WheelEvent::Type)jarg2;
28284   if (arg1) (arg1)->type = arg2;
28285 }
28286
28287
28288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28289   int jresult ;
28290   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28291   Dali::WheelEvent::Type result;
28292
28293   arg1 = (Dali::WheelEvent *)jarg1;
28294   result = (Dali::WheelEvent::Type) ((arg1)->type);
28295   jresult = (int)result;
28296   return jresult;
28297 }
28298
28299
28300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28301   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28302   int arg2 ;
28303
28304   arg1 = (Dali::WheelEvent *)jarg1;
28305   arg2 = (int)jarg2;
28306   if (arg1) (arg1)->direction = arg2;
28307 }
28308
28309
28310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28311   int jresult ;
28312   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28313   int result;
28314
28315   arg1 = (Dali::WheelEvent *)jarg1;
28316   result = (int) ((arg1)->direction);
28317   jresult = result;
28318   return jresult;
28319 }
28320
28321
28322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28323   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28324   unsigned int arg2 ;
28325
28326   arg1 = (Dali::WheelEvent *)jarg1;
28327   arg2 = (unsigned int)jarg2;
28328   if (arg1) (arg1)->modifiers = arg2;
28329 }
28330
28331
28332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28333   unsigned int jresult ;
28334   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28335   unsigned int result;
28336
28337   arg1 = (Dali::WheelEvent *)jarg1;
28338   result = (unsigned int) ((arg1)->modifiers);
28339   jresult = result;
28340   return jresult;
28341 }
28342
28343
28344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28345   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28346   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28347
28348   arg1 = (Dali::WheelEvent *)jarg1;
28349   arg2 = (Dali::Vector2 *)jarg2;
28350   if (arg1) (arg1)->point = *arg2;
28351 }
28352
28353
28354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28355   void * jresult ;
28356   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28357   Dali::Vector2 *result = 0 ;
28358
28359   arg1 = (Dali::WheelEvent *)jarg1;
28360   result = (Dali::Vector2 *)& ((arg1)->point);
28361   jresult = (void *)result;
28362   return jresult;
28363 }
28364
28365
28366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28367   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28368   int arg2 ;
28369
28370   arg1 = (Dali::WheelEvent *)jarg1;
28371   arg2 = (int)jarg2;
28372   if (arg1) (arg1)->z = arg2;
28373 }
28374
28375
28376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28377   int jresult ;
28378   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28379   int result;
28380
28381   arg1 = (Dali::WheelEvent *)jarg1;
28382   result = (int) ((arg1)->z);
28383   jresult = result;
28384   return jresult;
28385 }
28386
28387
28388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28389   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28390   unsigned int arg2 ;
28391
28392   arg1 = (Dali::WheelEvent *)jarg1;
28393   arg2 = (unsigned int)jarg2;
28394   if (arg1) (arg1)->timeStamp = arg2;
28395 }
28396
28397
28398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28399   unsigned int jresult ;
28400   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28401   unsigned int result;
28402
28403   arg1 = (Dali::WheelEvent *)jarg1;
28404   result = (unsigned int) ((arg1)->timeStamp);
28405   jresult = result;
28406   return jresult;
28407 }
28408
28409 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28410   char * jresult ;
28411   Dali::KeyEvent *arg1 = 0 ;
28412   std::string result;
28413
28414   arg1 = (Dali::KeyEvent *)jarg1;
28415   if (!arg1) {
28416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28417     return 0;
28418   }
28419   {
28420     try {
28421       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28422     } catch (std::out_of_range& e) {
28423       {
28424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28425       };
28426     } catch (std::exception& e) {
28427       {
28428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28429       };
28430     } catch (...) {
28431       {
28432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28433       };
28434     }
28435   }
28436   jresult = SWIG_csharp_string_callback((&result)->c_str());
28437   return jresult;
28438 }
28439
28440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28441   int jresult ;
28442   Dali::KeyEvent *arg1 = 0 ;
28443   Dali::DevelDevice::Class::Type result;
28444
28445   arg1 = (Dali::KeyEvent *)jarg1;
28446   if (!arg1) {
28447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28448     return 0;
28449   }
28450   {
28451     try {
28452       result = (Dali::DevelDevice::Class::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28453     } catch (std::out_of_range& e) {
28454       {
28455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28456       };
28457     } catch (std::exception& e) {
28458       {
28459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28460       };
28461     } catch (...) {
28462       {
28463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28464       };
28465     }
28466   }
28467   jresult = (int)result;
28468   return jresult;
28469 }
28470
28471
28472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28473   Dali::Actor arg1 ;
28474   Dali::Actor *argp1 ;
28475
28476   argp1 = (Dali::Actor *)jarg1;
28477   if (!argp1) {
28478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28479     return ;
28480   }
28481   arg1 = *argp1;
28482   {
28483     try {
28484       Dali::DevelActor::Raise(arg1);
28485     } catch (std::out_of_range& e) {
28486       {
28487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28488       };
28489     } catch (std::exception& e) {
28490       {
28491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28496       };
28497     }
28498   }
28499 }
28500
28501
28502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28503   Dali::Actor arg1 ;
28504   Dali::Actor *argp1 ;
28505
28506   argp1 = (Dali::Actor *)jarg1;
28507   if (!argp1) {
28508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28509     return ;
28510   }
28511   arg1 = *argp1;
28512   {
28513     try {
28514       Dali::DevelActor::Lower(arg1);
28515     } catch (std::out_of_range& e) {
28516       {
28517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28518       };
28519     } catch (std::exception& e) {
28520       {
28521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28522       };
28523     } catch (...) {
28524       {
28525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28526       };
28527     }
28528   }
28529 }
28530
28531
28532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28533   Dali::Actor arg1 ;
28534   Dali::Actor *argp1 ;
28535
28536   argp1 = (Dali::Actor *)jarg1;
28537   if (!argp1) {
28538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28539     return ;
28540   }
28541   arg1 = *argp1;
28542   {
28543     try {
28544       Dali::DevelActor::RaiseToTop(arg1);
28545     } catch (std::out_of_range& e) {
28546       {
28547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28548       };
28549     } catch (std::exception& e) {
28550       {
28551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (...) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28556       };
28557     }
28558   }
28559 }
28560
28561
28562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28563   Dali::Actor arg1 ;
28564   Dali::Actor *argp1 ;
28565
28566   argp1 = (Dali::Actor *)jarg1;
28567   if (!argp1) {
28568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28569     return ;
28570   }
28571   arg1 = *argp1;
28572   {
28573     try {
28574       Dali::DevelActor::LowerToBottom(arg1);
28575     } catch (std::out_of_range& e) {
28576       {
28577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28578       };
28579     } catch (std::exception& e) {
28580       {
28581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28582       };
28583     } catch (...) {
28584       {
28585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28586       };
28587     }
28588   }
28589 }
28590
28591
28592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28593   Dali::Actor arg1 ;
28594   Dali::Actor arg2 ;
28595   Dali::Actor *argp1 ;
28596   Dali::Actor *argp2 ;
28597
28598   argp1 = (Dali::Actor *)jarg1;
28599   if (!argp1) {
28600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28601     return ;
28602   }
28603   arg1 = *argp1;
28604   argp2 = (Dali::Actor *)jarg2;
28605   if (!argp2) {
28606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28607     return ;
28608   }
28609   arg2 = *argp2;
28610   {
28611     try {
28612       Dali::DevelActor::RaiseAbove(arg1,arg2);
28613     } catch (std::out_of_range& e) {
28614       {
28615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28616       };
28617     } catch (std::exception& e) {
28618       {
28619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28620       };
28621     } catch (...) {
28622       {
28623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28624       };
28625     }
28626   }
28627 }
28628
28629
28630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28631   Dali::Actor arg1 ;
28632   Dali::Actor arg2 ;
28633   Dali::Actor *argp1 ;
28634   Dali::Actor *argp2 ;
28635
28636   argp1 = (Dali::Actor *)jarg1;
28637   if (!argp1) {
28638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28639     return ;
28640   }
28641   arg1 = *argp1;
28642   argp2 = (Dali::Actor *)jarg2;
28643   if (!argp2) {
28644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28645     return ;
28646   }
28647   arg2 = *argp2;
28648   {
28649     try {
28650       Dali::DevelActor::LowerBelow(arg1,arg2);
28651     } catch (std::out_of_range& e) {
28652       {
28653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28654       };
28655     } catch (std::exception& e) {
28656       {
28657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28658       };
28659     } catch (...) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28662       };
28663     }
28664   }
28665 }
28666
28667
28668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28669   void * jresult ;
28670   Dali::Actor arg1 ;
28671   Dali::Actor *argp1 ;
28672   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28673
28674   argp1 = (Dali::Actor *)jarg1;
28675   if (!argp1) {
28676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28677     return 0;
28678   }
28679   arg1 = *argp1;
28680   {
28681     try {
28682       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28683     } catch (std::out_of_range& e) {
28684       {
28685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28686       };
28687     } catch (std::exception& e) {
28688       {
28689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28690       };
28691     } catch (...) {
28692       {
28693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28694       };
28695     }
28696   }
28697   jresult = (void *)result;
28698   return jresult;
28699 }
28700
28701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28702   int jresult ;
28703   int result;
28704
28705   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28706   jresult = (int)result;
28707   return jresult;
28708 }
28709
28710
28711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28712   int jresult ;
28713   int result;
28714
28715   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28716   jresult = (int)result;
28717   return jresult;
28718 }
28719
28720
28721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28722   int jresult ;
28723   int result;
28724
28725   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28726   jresult = (int)result;
28727   return jresult;
28728 }
28729
28730
28731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28732   int jresult ;
28733   int result;
28734
28735   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28736   jresult = (int)result;
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28742   int jresult ;
28743   int result;
28744
28745   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28746   jresult = (int)result;
28747   return jresult;
28748 }
28749
28750
28751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28752   int jresult ;
28753   int result;
28754
28755   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28756   jresult = (int)result;
28757   return jresult;
28758 }
28759
28760
28761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28762   int jresult ;
28763   int result;
28764
28765   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28766   jresult = (int)result;
28767   return jresult;
28768 }
28769
28770
28771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28772   int jresult ;
28773   int result;
28774
28775   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28776   jresult = (int)result;
28777   return jresult;
28778 }
28779
28780
28781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28782   int jresult ;
28783   int result;
28784
28785   result = (int)Dali::Actor::Property::SIZE;
28786   jresult = (int)result;
28787   return jresult;
28788 }
28789
28790
28791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28792   int jresult ;
28793   int result;
28794
28795   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28796   jresult = (int)result;
28797   return jresult;
28798 }
28799
28800
28801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28802   int jresult ;
28803   int result;
28804
28805   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28806   jresult = (int)result;
28807   return jresult;
28808 }
28809
28810
28811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28812   int jresult ;
28813   int result;
28814
28815   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28816   jresult = (int)result;
28817   return jresult;
28818 }
28819
28820
28821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28822   int jresult ;
28823   int result;
28824
28825   result = (int)Dali::Actor::Property::POSITION;
28826   jresult = (int)result;
28827   return jresult;
28828 }
28829
28830
28831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28832   int jresult ;
28833   int result;
28834
28835   result = (int)Dali::Actor::Property::POSITION_X;
28836   jresult = (int)result;
28837   return jresult;
28838 }
28839
28840
28841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28842   int jresult ;
28843   int result;
28844
28845   result = (int)Dali::Actor::Property::POSITION_Y;
28846   jresult = (int)result;
28847   return jresult;
28848 }
28849
28850
28851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28852   int jresult ;
28853   int result;
28854
28855   result = (int)Dali::Actor::Property::POSITION_Z;
28856   jresult = (int)result;
28857   return jresult;
28858 }
28859
28860
28861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28862   int jresult ;
28863   int result;
28864
28865   result = (int)Dali::Actor::Property::WORLD_POSITION;
28866   jresult = (int)result;
28867   return jresult;
28868 }
28869
28870
28871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28872   int jresult ;
28873   int result;
28874
28875   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28876   jresult = (int)result;
28877   return jresult;
28878 }
28879
28880
28881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28882   int jresult ;
28883   int result;
28884
28885   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28886   jresult = (int)result;
28887   return jresult;
28888 }
28889
28890
28891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28892   int jresult ;
28893   int result;
28894
28895   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28896   jresult = (int)result;
28897   return jresult;
28898 }
28899
28900
28901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28902   int jresult ;
28903   int result;
28904
28905   result = (int)Dali::Actor::Property::ORIENTATION;
28906   jresult = (int)result;
28907   return jresult;
28908 }
28909
28910
28911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28912   int jresult ;
28913   int result;
28914
28915   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28916   jresult = (int)result;
28917   return jresult;
28918 }
28919
28920
28921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28922   int jresult ;
28923   int result;
28924
28925   result = (int)Dali::Actor::Property::SCALE;
28926   jresult = (int)result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28932   int jresult ;
28933   int result;
28934
28935   result = (int)Dali::Actor::Property::SCALE_X;
28936   jresult = (int)result;
28937   return jresult;
28938 }
28939
28940
28941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28942   int jresult ;
28943   int result;
28944
28945   result = (int)Dali::Actor::Property::SCALE_Y;
28946   jresult = (int)result;
28947   return jresult;
28948 }
28949
28950
28951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28952   int jresult ;
28953   int result;
28954
28955   result = (int)Dali::Actor::Property::SCALE_Z;
28956   jresult = (int)result;
28957   return jresult;
28958 }
28959
28960
28961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28962   int jresult ;
28963   int result;
28964
28965   result = (int)Dali::Actor::Property::WORLD_SCALE;
28966   jresult = (int)result;
28967   return jresult;
28968 }
28969
28970
28971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28972   int jresult ;
28973   int result;
28974
28975   result = (int)Dali::Actor::Property::VISIBLE;
28976   jresult = (int)result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28982   int jresult ;
28983   int result;
28984
28985   result = (int)Dali::Actor::Property::COLOR;
28986   jresult = (int)result;
28987   return jresult;
28988 }
28989
28990
28991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28992   int jresult ;
28993   int result;
28994
28995   result = (int)Dali::Actor::Property::COLOR_RED;
28996   jresult = (int)result;
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29002   int jresult ;
29003   int result;
29004
29005   result = (int)Dali::Actor::Property::COLOR_GREEN;
29006   jresult = (int)result;
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29012   int jresult ;
29013   int result;
29014
29015   result = (int)Dali::Actor::Property::COLOR_BLUE;
29016   jresult = (int)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29022   int jresult ;
29023   int result;
29024
29025   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29026   jresult = (int)result;
29027   return jresult;
29028 }
29029
29030
29031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29032   int jresult ;
29033   int result;
29034
29035   result = (int)Dali::Actor::Property::WORLD_COLOR;
29036   jresult = (int)result;
29037   return jresult;
29038 }
29039
29040
29041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29042   int jresult ;
29043   int result;
29044
29045   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29046   jresult = (int)result;
29047   return jresult;
29048 }
29049
29050
29051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29052   int jresult ;
29053   int result;
29054
29055   result = (int)Dali::Actor::Property::NAME;
29056   jresult = (int)result;
29057   return jresult;
29058 }
29059
29060
29061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29062   int jresult ;
29063   int result;
29064
29065   result = (int)Dali::Actor::Property::SENSITIVE;
29066   jresult = (int)result;
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29072   int jresult ;
29073   int result;
29074
29075   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29076   jresult = (int)result;
29077   return jresult;
29078 }
29079
29080
29081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29082   int jresult ;
29083   int result;
29084
29085   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29086   jresult = (int)result;
29087   return jresult;
29088 }
29089
29090
29091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29092   int jresult ;
29093   int result;
29094
29095   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29096   jresult = (int)result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29102   int jresult ;
29103   int result;
29104
29105   result = (int)Dali::Actor::Property::COLOR_MODE;
29106   jresult = (int)result;
29107   return jresult;
29108 }
29109
29110
29111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29112   int jresult ;
29113   int result;
29114
29115   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29116   jresult = (int)result;
29117   return jresult;
29118 }
29119
29120
29121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29122   int jresult ;
29123   int result;
29124
29125   result = (int)Dali::Actor::Property::DRAW_MODE;
29126   jresult = (int)result;
29127   return jresult;
29128 }
29129
29130
29131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29132   int jresult ;
29133   int result;
29134
29135   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29136   jresult = (int)result;
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29142   int jresult ;
29143   int result;
29144
29145   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29146   jresult = (int)result;
29147   return jresult;
29148 }
29149
29150
29151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29152   int jresult ;
29153   int result;
29154
29155   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29156   jresult = (int)result;
29157   return jresult;
29158 }
29159
29160
29161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29162   int jresult ;
29163   int result;
29164
29165   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29166   jresult = (int)result;
29167   return jresult;
29168 }
29169
29170
29171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29172   int jresult ;
29173   int result;
29174
29175   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29176   jresult = (int)result;
29177   return jresult;
29178 }
29179
29180
29181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29182   int jresult ;
29183   int result;
29184
29185   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29186   jresult = (int)result;
29187   return jresult;
29188 }
29189
29190
29191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29192   int jresult ;
29193   int result;
29194
29195   result = (int)Dali::Actor::Property::PADDING;
29196   jresult = (int)result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29202   int jresult ;
29203   int result;
29204
29205   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29206   jresult = (int)result;
29207   return jresult;
29208 }
29209
29210
29211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29212   int jresult ;
29213   int result;
29214
29215   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29216   jresult = (int)result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29222   int jresult ;
29223   int result;
29224
29225   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29226   jresult = (int)result;
29227   return jresult;
29228 }
29229
29230
29231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29232   int jresult ;
29233   int result;
29234
29235   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29236   jresult = (int)result;
29237   return jresult;
29238 }
29239
29240
29241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29242   void * jresult ;
29243   Dali::Actor::Property *result = 0 ;
29244
29245   {
29246     try {
29247       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29248     } catch (std::out_of_range& e) {
29249       {
29250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29251       };
29252     } catch (std::exception& e) {
29253       {
29254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29255       };
29256     } catch (...) {
29257       {
29258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29259       };
29260     }
29261   }
29262   jresult = (void *)result;
29263   return jresult;
29264 }
29265
29266
29267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29268   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29269
29270   arg1 = (Dali::Actor::Property *)jarg1;
29271   {
29272     try {
29273       delete arg1;
29274     } catch (std::out_of_range& e) {
29275       {
29276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29277       };
29278     } catch (std::exception& e) {
29279       {
29280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29281       };
29282     } catch (...) {
29283       {
29284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29285       };
29286     }
29287   }
29288 }
29289
29290
29291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29292   void * jresult ;
29293   Dali::Actor *result = 0 ;
29294
29295   {
29296     try {
29297       result = (Dali::Actor *)new Dali::Actor();
29298     } catch (std::out_of_range& e) {
29299       {
29300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29301       };
29302     } catch (std::exception& e) {
29303       {
29304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29305       };
29306     } catch (...) {
29307       {
29308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29309       };
29310     }
29311   }
29312   jresult = (void *)result;
29313   return jresult;
29314 }
29315
29316
29317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29318   void * jresult ;
29319   Dali::Actor result;
29320
29321   {
29322     try {
29323       result = Dali::Actor::New();
29324     } catch (std::out_of_range& e) {
29325       {
29326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (std::exception& e) {
29329       {
29330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29331       };
29332     } catch (...) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29335       };
29336     }
29337   }
29338   jresult = new Dali::Actor((const Dali::Actor &)result);
29339   return jresult;
29340 }
29341
29342
29343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29344   void * jresult ;
29345   Dali::BaseHandle arg1 ;
29346   Dali::BaseHandle *argp1 ;
29347   Dali::Actor result;
29348
29349   argp1 = (Dali::BaseHandle *)jarg1;
29350   if (!argp1) {
29351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29352     return 0;
29353   }
29354   arg1 = *argp1;
29355   {
29356     try {
29357       result = Dali::Actor::DownCast(arg1);
29358     } catch (std::out_of_range& e) {
29359       {
29360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29361       };
29362     } catch (std::exception& e) {
29363       {
29364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29365       };
29366     } catch (...) {
29367       {
29368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29369       };
29370     }
29371   }
29372   jresult = new Dali::Actor((const Dali::Actor &)result);
29373   return jresult;
29374 }
29375
29376
29377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29379
29380   arg1 = (Dali::Actor *)jarg1;
29381   {
29382     try {
29383       delete arg1;
29384     } catch (std::out_of_range& e) {
29385       {
29386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29387       };
29388     } catch (std::exception& e) {
29389       {
29390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29391       };
29392     } catch (...) {
29393       {
29394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29395       };
29396     }
29397   }
29398 }
29399
29400
29401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29402   void * jresult ;
29403   Dali::Actor *arg1 = 0 ;
29404   Dali::Actor *result = 0 ;
29405
29406   arg1 = (Dali::Actor *)jarg1;
29407   if (!arg1) {
29408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29409     return 0;
29410   }
29411   {
29412     try {
29413       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29414     } catch (std::out_of_range& e) {
29415       {
29416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29417       };
29418     } catch (std::exception& e) {
29419       {
29420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29421       };
29422     } catch (...) {
29423       {
29424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29425       };
29426     }
29427   }
29428   jresult = (void *)result;
29429   return jresult;
29430 }
29431
29432
29433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29434   void * jresult ;
29435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29436   Dali::Actor *arg2 = 0 ;
29437   Dali::Actor *result = 0 ;
29438
29439   arg1 = (Dali::Actor *)jarg1;
29440   arg2 = (Dali::Actor *)jarg2;
29441   if (!arg2) {
29442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29443     return 0;
29444   }
29445   {
29446     try {
29447       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29448     } catch (std::out_of_range& e) {
29449       {
29450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29451       };
29452     } catch (std::exception& e) {
29453       {
29454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29455       };
29456     } catch (...) {
29457       {
29458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29459       };
29460     }
29461   }
29462   jresult = (void *)result;
29463   return jresult;
29464 }
29465
29466
29467 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29468   char * jresult ;
29469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29470   std::string *result = 0 ;
29471
29472   arg1 = (Dali::Actor *)jarg1;
29473   {
29474     try {
29475       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29476     } catch (std::out_of_range& e) {
29477       {
29478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29479       };
29480     } catch (std::exception& e) {
29481       {
29482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29483       };
29484     } catch (...) {
29485       {
29486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29487       };
29488     }
29489   }
29490   jresult = SWIG_csharp_string_callback(result->c_str());
29491   return jresult;
29492 }
29493
29494
29495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29497   std::string *arg2 = 0 ;
29498
29499   arg1 = (Dali::Actor *)jarg1;
29500   if (!jarg2) {
29501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29502     return ;
29503   }
29504   std::string arg2_str(jarg2);
29505   arg2 = &arg2_str;
29506   {
29507     try {
29508       (arg1)->SetName((std::string const &)*arg2);
29509     } catch (std::out_of_range& e) {
29510       {
29511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29512       };
29513     } catch (std::exception& e) {
29514       {
29515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29516       };
29517     } catch (...) {
29518       {
29519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29520       };
29521     }
29522   }
29523
29524   //argout typemap for const std::string&
29525
29526 }
29527
29528
29529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29530   unsigned int jresult ;
29531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29532   unsigned int result;
29533
29534   arg1 = (Dali::Actor *)jarg1;
29535   {
29536     try {
29537       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29538     } catch (std::out_of_range& e) {
29539       {
29540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29541       };
29542     } catch (std::exception& e) {
29543       {
29544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (...) {
29547       {
29548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29549       };
29550     }
29551   }
29552   jresult = result;
29553   return jresult;
29554 }
29555
29556
29557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29558   unsigned int jresult ;
29559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29560   bool result;
29561
29562   arg1 = (Dali::Actor *)jarg1;
29563   {
29564     try {
29565       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29566     } catch (std::out_of_range& e) {
29567       {
29568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29569       };
29570     } catch (std::exception& e) {
29571       {
29572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29573       };
29574     } catch (...) {
29575       {
29576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29577       };
29578     }
29579   }
29580   jresult = result;
29581   return jresult;
29582 }
29583
29584
29585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29586   unsigned int jresult ;
29587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29588   bool result;
29589
29590   arg1 = (Dali::Actor *)jarg1;
29591   {
29592     try {
29593       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29594     } catch (std::out_of_range& e) {
29595       {
29596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29597       };
29598     } catch (std::exception& e) {
29599       {
29600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29601       };
29602     } catch (...) {
29603       {
29604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29605       };
29606     }
29607   }
29608   jresult = result;
29609   return jresult;
29610 }
29611
29612
29613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29614   unsigned int jresult ;
29615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29616   bool result;
29617
29618   arg1 = (Dali::Actor *)jarg1;
29619   {
29620     try {
29621       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29622     } catch (std::out_of_range& e) {
29623       {
29624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29625       };
29626     } catch (std::exception& e) {
29627       {
29628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29629       };
29630     } catch (...) {
29631       {
29632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29633       };
29634     }
29635   }
29636   jresult = result;
29637   return jresult;
29638 }
29639
29640
29641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29642   void * jresult ;
29643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29644   Dali::Layer result;
29645
29646   arg1 = (Dali::Actor *)jarg1;
29647   {
29648     try {
29649       result = (arg1)->GetLayer();
29650     } catch (std::out_of_range& e) {
29651       {
29652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29653       };
29654     } catch (std::exception& e) {
29655       {
29656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29657       };
29658     } catch (...) {
29659       {
29660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29661       };
29662     }
29663   }
29664   jresult = new Dali::Layer((const Dali::Layer &)result);
29665   return jresult;
29666 }
29667
29668
29669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29671   Dali::Actor arg2 ;
29672   Dali::Actor *argp2 ;
29673
29674   arg1 = (Dali::Actor *)jarg1;
29675   argp2 = (Dali::Actor *)jarg2;
29676   if (!argp2) {
29677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29678     return ;
29679   }
29680   arg2 = *argp2;
29681   {
29682     try {
29683       (arg1)->Add(arg2);
29684     } catch (std::out_of_range& e) {
29685       {
29686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29687       };
29688     } catch (std::exception& e) {
29689       {
29690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29691       };
29692     } catch (...) {
29693       {
29694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29695       };
29696     }
29697   }
29698 }
29699
29700
29701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29703   Dali::Actor arg2 ;
29704   Dali::Actor *argp2 ;
29705
29706   arg1 = (Dali::Actor *)jarg1;
29707   argp2 = (Dali::Actor *)jarg2;
29708   if (!argp2) {
29709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29710     return ;
29711   }
29712   arg2 = *argp2;
29713   {
29714     try {
29715       (arg1)->Remove(arg2);
29716     } catch (std::out_of_range& e) {
29717       {
29718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29719       };
29720     } catch (std::exception& e) {
29721       {
29722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29723       };
29724     } catch (...) {
29725       {
29726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29727       };
29728     }
29729   }
29730 }
29731
29732
29733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29735
29736   arg1 = (Dali::Actor *)jarg1;
29737   {
29738     try {
29739       (arg1)->Unparent();
29740     } catch (std::out_of_range& e) {
29741       {
29742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29743       };
29744     } catch (std::exception& e) {
29745       {
29746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29747       };
29748     } catch (...) {
29749       {
29750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29751       };
29752     }
29753   }
29754 }
29755
29756
29757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29758   unsigned int jresult ;
29759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29760   unsigned int result;
29761
29762   arg1 = (Dali::Actor *)jarg1;
29763   {
29764     try {
29765       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29766     } catch (std::out_of_range& e) {
29767       {
29768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29769       };
29770     } catch (std::exception& e) {
29771       {
29772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29773       };
29774     } catch (...) {
29775       {
29776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29777       };
29778     }
29779   }
29780   jresult = result;
29781   return jresult;
29782 }
29783
29784
29785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29786   void * jresult ;
29787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29788   unsigned int arg2 ;
29789   Dali::Actor result;
29790
29791   arg1 = (Dali::Actor *)jarg1;
29792   arg2 = (unsigned int)jarg2;
29793   {
29794     try {
29795       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29796     } catch (std::out_of_range& e) {
29797       {
29798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29799       };
29800     } catch (std::exception& e) {
29801       {
29802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29803       };
29804     } catch (...) {
29805       {
29806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29807       };
29808     }
29809   }
29810   jresult = new Dali::Actor((const Dali::Actor &)result);
29811   return jresult;
29812 }
29813
29814
29815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29816   void * jresult ;
29817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29818   std::string *arg2 = 0 ;
29819   Dali::Actor result;
29820
29821   arg1 = (Dali::Actor *)jarg1;
29822   if (!jarg2) {
29823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29824     return 0;
29825   }
29826   std::string arg2_str(jarg2);
29827   arg2 = &arg2_str;
29828   {
29829     try {
29830       result = (arg1)->FindChildByName((std::string const &)*arg2);
29831     } catch (std::out_of_range& e) {
29832       {
29833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29834       };
29835     } catch (std::exception& e) {
29836       {
29837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29838       };
29839     } catch (...) {
29840       {
29841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29842       };
29843     }
29844   }
29845   jresult = new Dali::Actor((const Dali::Actor &)result);
29846
29847   //argout typemap for const std::string&
29848
29849   return jresult;
29850 }
29851
29852
29853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29854   void * jresult ;
29855   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29856   unsigned int arg2 ;
29857   Dali::Actor result;
29858
29859   arg1 = (Dali::Actor *)jarg1;
29860   arg2 = (unsigned int)jarg2;
29861   {
29862     try {
29863       result = (arg1)->FindChildById(arg2);
29864     } catch (std::out_of_range& e) {
29865       {
29866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (std::exception& e) {
29869       {
29870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29871       };
29872     } catch (...) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29875       };
29876     }
29877   }
29878   jresult = new Dali::Actor((const Dali::Actor &)result);
29879   return jresult;
29880 }
29881
29882
29883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29884   void * jresult ;
29885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29886   Dali::Actor result;
29887
29888   arg1 = (Dali::Actor *)jarg1;
29889   {
29890     try {
29891       result = ((Dali::Actor const *)arg1)->GetParent();
29892     } catch (std::out_of_range& e) {
29893       {
29894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29895       };
29896     } catch (std::exception& e) {
29897       {
29898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29899       };
29900     } catch (...) {
29901       {
29902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29903       };
29904     }
29905   }
29906   jresult = new Dali::Actor((const Dali::Actor &)result);
29907   return jresult;
29908 }
29909
29910
29911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29913   Dali::Vector3 *arg2 = 0 ;
29914
29915   arg1 = (Dali::Actor *)jarg1;
29916   arg2 = (Dali::Vector3 *)jarg2;
29917   if (!arg2) {
29918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29919     return ;
29920   }
29921   {
29922     try {
29923       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29924     } catch (std::out_of_range& e) {
29925       {
29926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29927       };
29928     } catch (std::exception& e) {
29929       {
29930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29931       };
29932     } catch (...) {
29933       {
29934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29935       };
29936     }
29937   }
29938 }
29939
29940
29941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29942   void * jresult ;
29943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29944   Dali::Vector3 result;
29945
29946   arg1 = (Dali::Actor *)jarg1;
29947   {
29948     try {
29949       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29950     } catch (std::out_of_range& e) {
29951       {
29952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29953       };
29954     } catch (std::exception& e) {
29955       {
29956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29957       };
29958     } catch (...) {
29959       {
29960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29961       };
29962     }
29963   }
29964   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29965   return jresult;
29966 }
29967
29968
29969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29971   Dali::Vector3 *arg2 = 0 ;
29972
29973   arg1 = (Dali::Actor *)jarg1;
29974   arg2 = (Dali::Vector3 *)jarg2;
29975   if (!arg2) {
29976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29977     return ;
29978   }
29979   {
29980     try {
29981       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29982     } catch (std::out_of_range& e) {
29983       {
29984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29985       };
29986     } catch (std::exception& e) {
29987       {
29988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29989       };
29990     } catch (...) {
29991       {
29992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29993       };
29994     }
29995   }
29996 }
29997
29998
29999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30000   void * jresult ;
30001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30002   Dali::Vector3 result;
30003
30004   arg1 = (Dali::Actor *)jarg1;
30005   {
30006     try {
30007       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30008     } catch (std::out_of_range& e) {
30009       {
30010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30011       };
30012     } catch (std::exception& e) {
30013       {
30014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (...) {
30017       {
30018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30019       };
30020     }
30021   }
30022   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30023   return jresult;
30024 }
30025
30026
30027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30029   float arg2 ;
30030   float arg3 ;
30031
30032   arg1 = (Dali::Actor *)jarg1;
30033   arg2 = (float)jarg2;
30034   arg3 = (float)jarg3;
30035   {
30036     try {
30037       (arg1)->SetSize(arg2,arg3);
30038     } catch (std::out_of_range& e) {
30039       {
30040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30041       };
30042     } catch (std::exception& e) {
30043       {
30044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30045       };
30046     } catch (...) {
30047       {
30048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30049       };
30050     }
30051   }
30052 }
30053
30054
30055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30056   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30057   float arg2 ;
30058   float arg3 ;
30059   float arg4 ;
30060
30061   arg1 = (Dali::Actor *)jarg1;
30062   arg2 = (float)jarg2;
30063   arg3 = (float)jarg3;
30064   arg4 = (float)jarg4;
30065   {
30066     try {
30067       (arg1)->SetSize(arg2,arg3,arg4);
30068     } catch (std::out_of_range& e) {
30069       {
30070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30071       };
30072     } catch (std::exception& e) {
30073       {
30074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30075       };
30076     } catch (...) {
30077       {
30078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30079       };
30080     }
30081   }
30082 }
30083
30084
30085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30087   Dali::Vector2 *arg2 = 0 ;
30088
30089   arg1 = (Dali::Actor *)jarg1;
30090   arg2 = (Dali::Vector2 *)jarg2;
30091   if (!arg2) {
30092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30093     return ;
30094   }
30095   {
30096     try {
30097       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30098     } catch (std::out_of_range& e) {
30099       {
30100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30101       };
30102     } catch (std::exception& e) {
30103       {
30104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30105       };
30106     } catch (...) {
30107       {
30108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30109       };
30110     }
30111   }
30112 }
30113
30114
30115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30117   Dali::Vector3 *arg2 = 0 ;
30118
30119   arg1 = (Dali::Actor *)jarg1;
30120   arg2 = (Dali::Vector3 *)jarg2;
30121   if (!arg2) {
30122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30123     return ;
30124   }
30125   {
30126     try {
30127       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30128     } catch (std::out_of_range& e) {
30129       {
30130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30131       };
30132     } catch (std::exception& e) {
30133       {
30134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30135       };
30136     } catch (...) {
30137       {
30138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30139       };
30140     }
30141   }
30142 }
30143
30144
30145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30146   void * jresult ;
30147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30148   Dali::Vector3 result;
30149
30150   arg1 = (Dali::Actor *)jarg1;
30151   {
30152     try {
30153       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30154     } catch (std::out_of_range& e) {
30155       {
30156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30157       };
30158     } catch (std::exception& e) {
30159       {
30160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30161       };
30162     } catch (...) {
30163       {
30164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30165       };
30166     }
30167   }
30168   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30169   return jresult;
30170 }
30171
30172
30173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30174   void * jresult ;
30175   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30176   Dali::Vector3 result;
30177
30178   arg1 = (Dali::Actor *)jarg1;
30179   {
30180     try {
30181       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30182     } catch (std::out_of_range& e) {
30183       {
30184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30185       };
30186     } catch (std::exception& e) {
30187       {
30188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30189       };
30190     } catch (...) {
30191       {
30192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30193       };
30194     }
30195   }
30196   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30197   return jresult;
30198 }
30199
30200
30201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30202   void * jresult ;
30203   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30204   Dali::Vector3 result;
30205
30206   arg1 = (Dali::Actor *)jarg1;
30207   {
30208     try {
30209       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30210     } catch (std::out_of_range& e) {
30211       {
30212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30213       };
30214     } catch (std::exception& e) {
30215       {
30216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30221       };
30222     }
30223   }
30224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30225   return jresult;
30226 }
30227
30228
30229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30231   float arg2 ;
30232   float arg3 ;
30233
30234   arg1 = (Dali::Actor *)jarg1;
30235   arg2 = (float)jarg2;
30236   arg3 = (float)jarg3;
30237   {
30238     try {
30239       (arg1)->SetPosition(arg2,arg3);
30240     } catch (std::out_of_range& e) {
30241       {
30242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30243       };
30244     } catch (std::exception& e) {
30245       {
30246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30247       };
30248     } catch (...) {
30249       {
30250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30251       };
30252     }
30253   }
30254 }
30255
30256
30257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30259   float arg2 ;
30260   float arg3 ;
30261   float arg4 ;
30262
30263   arg1 = (Dali::Actor *)jarg1;
30264   arg2 = (float)jarg2;
30265   arg3 = (float)jarg3;
30266   arg4 = (float)jarg4;
30267   {
30268     try {
30269       (arg1)->SetPosition(arg2,arg3,arg4);
30270     } catch (std::out_of_range& e) {
30271       {
30272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30273       };
30274     } catch (std::exception& e) {
30275       {
30276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30277       };
30278     } catch (...) {
30279       {
30280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30281       };
30282     }
30283   }
30284 }
30285
30286
30287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30289   Dali::Vector3 *arg2 = 0 ;
30290
30291   arg1 = (Dali::Actor *)jarg1;
30292   arg2 = (Dali::Vector3 *)jarg2;
30293   if (!arg2) {
30294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30295     return ;
30296   }
30297   {
30298     try {
30299       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30300     } catch (std::out_of_range& e) {
30301       {
30302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30303       };
30304     } catch (std::exception& e) {
30305       {
30306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30307       };
30308     } catch (...) {
30309       {
30310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30311       };
30312     }
30313   }
30314 }
30315
30316
30317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30319   float arg2 ;
30320
30321   arg1 = (Dali::Actor *)jarg1;
30322   arg2 = (float)jarg2;
30323   {
30324     try {
30325       (arg1)->SetX(arg2);
30326     } catch (std::out_of_range& e) {
30327       {
30328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30329       };
30330     } catch (std::exception& e) {
30331       {
30332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30333       };
30334     } catch (...) {
30335       {
30336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30337       };
30338     }
30339   }
30340 }
30341
30342
30343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30345   float arg2 ;
30346
30347   arg1 = (Dali::Actor *)jarg1;
30348   arg2 = (float)jarg2;
30349   {
30350     try {
30351       (arg1)->SetY(arg2);
30352     } catch (std::out_of_range& e) {
30353       {
30354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30355       };
30356     } catch (std::exception& e) {
30357       {
30358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30363       };
30364     }
30365   }
30366 }
30367
30368
30369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30371   float arg2 ;
30372
30373   arg1 = (Dali::Actor *)jarg1;
30374   arg2 = (float)jarg2;
30375   {
30376     try {
30377       (arg1)->SetZ(arg2);
30378     } catch (std::out_of_range& e) {
30379       {
30380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30381       };
30382     } catch (std::exception& e) {
30383       {
30384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30385       };
30386     } catch (...) {
30387       {
30388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30389       };
30390     }
30391   }
30392 }
30393
30394
30395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30397   Dali::Vector3 *arg2 = 0 ;
30398
30399   arg1 = (Dali::Actor *)jarg1;
30400   arg2 = (Dali::Vector3 *)jarg2;
30401   if (!arg2) {
30402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30403     return ;
30404   }
30405   {
30406     try {
30407       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30408     } catch (std::out_of_range& e) {
30409       {
30410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30411       };
30412     } catch (std::exception& e) {
30413       {
30414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30415       };
30416     } catch (...) {
30417       {
30418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30419       };
30420     }
30421   }
30422 }
30423
30424
30425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30426   void * jresult ;
30427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30428   Dali::Vector3 result;
30429
30430   arg1 = (Dali::Actor *)jarg1;
30431   {
30432     try {
30433       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30434     } catch (std::out_of_range& e) {
30435       {
30436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30437       };
30438     } catch (std::exception& e) {
30439       {
30440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30441       };
30442     } catch (...) {
30443       {
30444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30445       };
30446     }
30447   }
30448   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30449   return jresult;
30450 }
30451
30452
30453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30454   void * jresult ;
30455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30456   Dali::Vector3 result;
30457
30458   arg1 = (Dali::Actor *)jarg1;
30459   {
30460     try {
30461       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30462     } catch (std::out_of_range& e) {
30463       {
30464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30465       };
30466     } catch (std::exception& e) {
30467       {
30468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30469       };
30470     } catch (...) {
30471       {
30472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30473       };
30474     }
30475   }
30476   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30477   return jresult;
30478 }
30479
30480
30481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30483   bool arg2 ;
30484
30485   arg1 = (Dali::Actor *)jarg1;
30486   arg2 = jarg2 ? true : false;
30487   {
30488     try {
30489       (arg1)->SetInheritPosition(arg2);
30490     } catch (std::out_of_range& e) {
30491       {
30492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (std::exception& e) {
30495       {
30496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30497       };
30498     } catch (...) {
30499       {
30500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30501       };
30502     }
30503   }
30504 }
30505
30506
30507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30508   int jresult ;
30509   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30510   Dali::PositionInheritanceMode result;
30511
30512   arg1 = (Dali::Actor *)jarg1;
30513   {
30514     try {
30515       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30516     } catch (std::out_of_range& e) {
30517       {
30518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30519       };
30520     } catch (std::exception& e) {
30521       {
30522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30523       };
30524     } catch (...) {
30525       {
30526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30527       };
30528     }
30529   }
30530   jresult = (int)result;
30531   return jresult;
30532 }
30533
30534
30535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30536   unsigned int jresult ;
30537   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30538   bool result;
30539
30540   arg1 = (Dali::Actor *)jarg1;
30541   {
30542     try {
30543       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30544     } catch (std::out_of_range& e) {
30545       {
30546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30547       };
30548     } catch (std::exception& e) {
30549       {
30550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30551       };
30552     } catch (...) {
30553       {
30554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30555       };
30556     }
30557   }
30558   jresult = result;
30559   return jresult;
30560 }
30561
30562
30563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30565   Dali::Degree *arg2 = 0 ;
30566   Dali::Vector3 *arg3 = 0 ;
30567
30568   arg1 = (Dali::Actor *)jarg1;
30569   arg2 = (Dali::Degree *)jarg2;
30570   if (!arg2) {
30571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30572     return ;
30573   }
30574   arg3 = (Dali::Vector3 *)jarg3;
30575   if (!arg3) {
30576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30577     return ;
30578   }
30579   {
30580     try {
30581       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30582     } catch (std::out_of_range& e) {
30583       {
30584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30585       };
30586     } catch (std::exception& e) {
30587       {
30588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30589       };
30590     } catch (...) {
30591       {
30592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30593       };
30594     }
30595   }
30596 }
30597
30598
30599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30601   Dali::Radian *arg2 = 0 ;
30602   Dali::Vector3 *arg3 = 0 ;
30603
30604   arg1 = (Dali::Actor *)jarg1;
30605   arg2 = (Dali::Radian *)jarg2;
30606   if (!arg2) {
30607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30608     return ;
30609   }
30610   arg3 = (Dali::Vector3 *)jarg3;
30611   if (!arg3) {
30612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30613     return ;
30614   }
30615   {
30616     try {
30617       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30618     } catch (std::out_of_range& e) {
30619       {
30620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30621       };
30622     } catch (std::exception& e) {
30623       {
30624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30625       };
30626     } catch (...) {
30627       {
30628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30629       };
30630     }
30631   }
30632 }
30633
30634
30635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30637   Dali::Quaternion *arg2 = 0 ;
30638
30639   arg1 = (Dali::Actor *)jarg1;
30640   arg2 = (Dali::Quaternion *)jarg2;
30641   if (!arg2) {
30642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30643     return ;
30644   }
30645   {
30646     try {
30647       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30648     } catch (std::out_of_range& e) {
30649       {
30650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30651       };
30652     } catch (std::exception& e) {
30653       {
30654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30655       };
30656     } catch (...) {
30657       {
30658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30659       };
30660     }
30661   }
30662 }
30663
30664
30665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30667   Dali::Degree *arg2 = 0 ;
30668   Dali::Vector3 *arg3 = 0 ;
30669
30670   arg1 = (Dali::Actor *)jarg1;
30671   arg2 = (Dali::Degree *)jarg2;
30672   if (!arg2) {
30673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30674     return ;
30675   }
30676   arg3 = (Dali::Vector3 *)jarg3;
30677   if (!arg3) {
30678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30679     return ;
30680   }
30681   {
30682     try {
30683       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30684     } catch (std::out_of_range& e) {
30685       {
30686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30687       };
30688     } catch (std::exception& e) {
30689       {
30690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30691       };
30692     } catch (...) {
30693       {
30694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30695       };
30696     }
30697   }
30698 }
30699
30700
30701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30703   Dali::Radian *arg2 = 0 ;
30704   Dali::Vector3 *arg3 = 0 ;
30705
30706   arg1 = (Dali::Actor *)jarg1;
30707   arg2 = (Dali::Radian *)jarg2;
30708   if (!arg2) {
30709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30710     return ;
30711   }
30712   arg3 = (Dali::Vector3 *)jarg3;
30713   if (!arg3) {
30714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30715     return ;
30716   }
30717   {
30718     try {
30719       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30720     } catch (std::out_of_range& e) {
30721       {
30722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30723       };
30724     } catch (std::exception& e) {
30725       {
30726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30727       };
30728     } catch (...) {
30729       {
30730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30731       };
30732     }
30733   }
30734 }
30735
30736
30737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30739   Dali::Quaternion *arg2 = 0 ;
30740
30741   arg1 = (Dali::Actor *)jarg1;
30742   arg2 = (Dali::Quaternion *)jarg2;
30743   if (!arg2) {
30744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30745     return ;
30746   }
30747   {
30748     try {
30749       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30750     } catch (std::out_of_range& e) {
30751       {
30752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30753       };
30754     } catch (std::exception& e) {
30755       {
30756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30757       };
30758     } catch (...) {
30759       {
30760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30761       };
30762     }
30763   }
30764 }
30765
30766
30767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30768   void * jresult ;
30769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30770   Dali::Quaternion result;
30771
30772   arg1 = (Dali::Actor *)jarg1;
30773   {
30774     try {
30775       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30776     } catch (std::out_of_range& e) {
30777       {
30778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30779       };
30780     } catch (std::exception& e) {
30781       {
30782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30783       };
30784     } catch (...) {
30785       {
30786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30787       };
30788     }
30789   }
30790   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30797   bool arg2 ;
30798
30799   arg1 = (Dali::Actor *)jarg1;
30800   arg2 = jarg2 ? true : false;
30801   {
30802     try {
30803       (arg1)->SetInheritOrientation(arg2);
30804     } catch (std::out_of_range& e) {
30805       {
30806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30807       };
30808     } catch (std::exception& e) {
30809       {
30810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30811       };
30812     } catch (...) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30815       };
30816     }
30817   }
30818 }
30819
30820
30821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30822   unsigned int jresult ;
30823   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30824   bool result;
30825
30826   arg1 = (Dali::Actor *)jarg1;
30827   {
30828     try {
30829       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30830     } catch (std::out_of_range& e) {
30831       {
30832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30833       };
30834     } catch (std::exception& e) {
30835       {
30836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30837       };
30838     } catch (...) {
30839       {
30840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30841       };
30842     }
30843   }
30844   jresult = result;
30845   return jresult;
30846 }
30847
30848
30849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30850   void * jresult ;
30851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30852   Dali::Quaternion result;
30853
30854   arg1 = (Dali::Actor *)jarg1;
30855   {
30856     try {
30857       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30858     } catch (std::out_of_range& e) {
30859       {
30860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30861       };
30862     } catch (std::exception& e) {
30863       {
30864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30865       };
30866     } catch (...) {
30867       {
30868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30869       };
30870     }
30871   }
30872   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30873   return jresult;
30874 }
30875
30876
30877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30879   float arg2 ;
30880
30881   arg1 = (Dali::Actor *)jarg1;
30882   arg2 = (float)jarg2;
30883   {
30884     try {
30885       (arg1)->SetScale(arg2);
30886     } catch (std::out_of_range& e) {
30887       {
30888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30889       };
30890     } catch (std::exception& e) {
30891       {
30892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30893       };
30894     } catch (...) {
30895       {
30896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30897       };
30898     }
30899   }
30900 }
30901
30902
30903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30905   float arg2 ;
30906   float arg3 ;
30907   float arg4 ;
30908
30909   arg1 = (Dali::Actor *)jarg1;
30910   arg2 = (float)jarg2;
30911   arg3 = (float)jarg3;
30912   arg4 = (float)jarg4;
30913   {
30914     try {
30915       (arg1)->SetScale(arg2,arg3,arg4);
30916     } catch (std::out_of_range& e) {
30917       {
30918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30919       };
30920     } catch (std::exception& e) {
30921       {
30922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30923       };
30924     } catch (...) {
30925       {
30926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30927       };
30928     }
30929   }
30930 }
30931
30932
30933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30935   Dali::Vector3 *arg2 = 0 ;
30936
30937   arg1 = (Dali::Actor *)jarg1;
30938   arg2 = (Dali::Vector3 *)jarg2;
30939   if (!arg2) {
30940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30941     return ;
30942   }
30943   {
30944     try {
30945       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30946     } catch (std::out_of_range& e) {
30947       {
30948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30949       };
30950     } catch (std::exception& e) {
30951       {
30952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30953       };
30954     } catch (...) {
30955       {
30956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30957       };
30958     }
30959   }
30960 }
30961
30962
30963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30965   Dali::Vector3 *arg2 = 0 ;
30966
30967   arg1 = (Dali::Actor *)jarg1;
30968   arg2 = (Dali::Vector3 *)jarg2;
30969   if (!arg2) {
30970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30971     return ;
30972   }
30973   {
30974     try {
30975       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30976     } catch (std::out_of_range& e) {
30977       {
30978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30979       };
30980     } catch (std::exception& e) {
30981       {
30982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30983       };
30984     } catch (...) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30987       };
30988     }
30989   }
30990 }
30991
30992
30993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30994   void * jresult ;
30995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30996   Dali::Vector3 result;
30997
30998   arg1 = (Dali::Actor *)jarg1;
30999   {
31000     try {
31001       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31002     } catch (std::out_of_range& e) {
31003       {
31004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (std::exception& e) {
31007       {
31008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31009       };
31010     } catch (...) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31013       };
31014     }
31015   }
31016   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31017   return jresult;
31018 }
31019
31020
31021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31022   void * jresult ;
31023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31024   Dali::Vector3 result;
31025
31026   arg1 = (Dali::Actor *)jarg1;
31027   {
31028     try {
31029       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31030     } catch (std::out_of_range& e) {
31031       {
31032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31033       };
31034     } catch (std::exception& e) {
31035       {
31036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31037       };
31038     } catch (...) {
31039       {
31040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31041       };
31042     }
31043   }
31044   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31045   return jresult;
31046 }
31047
31048
31049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31051   bool arg2 ;
31052
31053   arg1 = (Dali::Actor *)jarg1;
31054   arg2 = jarg2 ? true : false;
31055   {
31056     try {
31057       (arg1)->SetInheritScale(arg2);
31058     } catch (std::out_of_range& e) {
31059       {
31060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31061       };
31062     } catch (std::exception& e) {
31063       {
31064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31065       };
31066     } catch (...) {
31067       {
31068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31069       };
31070     }
31071   }
31072 }
31073
31074
31075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31076   unsigned int jresult ;
31077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31078   bool result;
31079
31080   arg1 = (Dali::Actor *)jarg1;
31081   {
31082     try {
31083       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31084     } catch (std::out_of_range& e) {
31085       {
31086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31087       };
31088     } catch (std::exception& e) {
31089       {
31090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (...) {
31093       {
31094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31095       };
31096     }
31097   }
31098   jresult = result;
31099   return jresult;
31100 }
31101
31102
31103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31104   void * jresult ;
31105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31106   Dali::Matrix result;
31107
31108   arg1 = (Dali::Actor *)jarg1;
31109   {
31110     try {
31111       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31112     } catch (std::out_of_range& e) {
31113       {
31114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (std::exception& e) {
31117       {
31118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31119       };
31120     } catch (...) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31123       };
31124     }
31125   }
31126   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31127   return jresult;
31128 }
31129
31130
31131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31132   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31133   bool arg2 ;
31134
31135   arg1 = (Dali::Actor *)jarg1;
31136   arg2 = jarg2 ? true : false;
31137   {
31138     try {
31139       (arg1)->SetVisible(arg2);
31140     } catch (std::out_of_range& e) {
31141       {
31142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31143       };
31144     } catch (std::exception& e) {
31145       {
31146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31147       };
31148     } catch (...) {
31149       {
31150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31151       };
31152     }
31153   }
31154 }
31155
31156
31157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31158   unsigned int jresult ;
31159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31160   bool result;
31161
31162   arg1 = (Dali::Actor *)jarg1;
31163   {
31164     try {
31165       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31166     } catch (std::out_of_range& e) {
31167       {
31168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31169       };
31170     } catch (std::exception& e) {
31171       {
31172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31173       };
31174     } catch (...) {
31175       {
31176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31177       };
31178     }
31179   }
31180   jresult = result;
31181   return jresult;
31182 }
31183
31184
31185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31187   float arg2 ;
31188
31189   arg1 = (Dali::Actor *)jarg1;
31190   arg2 = (float)jarg2;
31191   {
31192     try {
31193       (arg1)->SetOpacity(arg2);
31194     } catch (std::out_of_range& e) {
31195       {
31196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31197       };
31198     } catch (std::exception& e) {
31199       {
31200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31201       };
31202     } catch (...) {
31203       {
31204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31205       };
31206     }
31207   }
31208 }
31209
31210
31211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31212   float jresult ;
31213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31214   float result;
31215
31216   arg1 = (Dali::Actor *)jarg1;
31217   {
31218     try {
31219       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31220     } catch (std::out_of_range& e) {
31221       {
31222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31223       };
31224     } catch (std::exception& e) {
31225       {
31226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31227       };
31228     } catch (...) {
31229       {
31230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31231       };
31232     }
31233   }
31234   jresult = result;
31235   return jresult;
31236 }
31237
31238
31239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31241   Dali::Vector4 *arg2 = 0 ;
31242
31243   arg1 = (Dali::Actor *)jarg1;
31244   arg2 = (Dali::Vector4 *)jarg2;
31245   if (!arg2) {
31246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31247     return ;
31248   }
31249   {
31250     try {
31251       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31252     } catch (std::out_of_range& e) {
31253       {
31254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31255       };
31256     } catch (std::exception& e) {
31257       {
31258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31259       };
31260     } catch (...) {
31261       {
31262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31263       };
31264     }
31265   }
31266 }
31267
31268
31269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31270   void * jresult ;
31271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31272   Dali::Vector4 result;
31273
31274   arg1 = (Dali::Actor *)jarg1;
31275   {
31276     try {
31277       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31278     } catch (std::out_of_range& e) {
31279       {
31280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31281       };
31282     } catch (std::exception& e) {
31283       {
31284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31285       };
31286     } catch (...) {
31287       {
31288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31289       };
31290     }
31291   }
31292   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31293   return jresult;
31294 }
31295
31296
31297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31299   Dali::ColorMode arg2 ;
31300
31301   arg1 = (Dali::Actor *)jarg1;
31302   arg2 = (Dali::ColorMode)jarg2;
31303   {
31304     try {
31305       (arg1)->SetColorMode(arg2);
31306     } catch (std::out_of_range& e) {
31307       {
31308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31309       };
31310     } catch (std::exception& e) {
31311       {
31312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31313       };
31314     } catch (...) {
31315       {
31316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31317       };
31318     }
31319   }
31320 }
31321
31322
31323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31324   int jresult ;
31325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31326   Dali::ColorMode result;
31327
31328   arg1 = (Dali::Actor *)jarg1;
31329   {
31330     try {
31331       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31332     } catch (std::out_of_range& e) {
31333       {
31334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31335       };
31336     } catch (std::exception& e) {
31337       {
31338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31339       };
31340     } catch (...) {
31341       {
31342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31343       };
31344     }
31345   }
31346   jresult = (int)result;
31347   return jresult;
31348 }
31349
31350
31351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31352   void * jresult ;
31353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31354   Dali::Vector4 result;
31355
31356   arg1 = (Dali::Actor *)jarg1;
31357   {
31358     try {
31359       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31360     } catch (std::out_of_range& e) {
31361       {
31362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31363       };
31364     } catch (std::exception& e) {
31365       {
31366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31367       };
31368     } catch (...) {
31369       {
31370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31371       };
31372     }
31373   }
31374   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31375   return jresult;
31376 }
31377
31378
31379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31381   Dali::DrawMode::Type arg2 ;
31382
31383   arg1 = (Dali::Actor *)jarg1;
31384   arg2 = (Dali::DrawMode::Type)jarg2;
31385   {
31386     try {
31387       (arg1)->SetDrawMode(arg2);
31388     } catch (std::out_of_range& e) {
31389       {
31390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31391       };
31392     } catch (std::exception& e) {
31393       {
31394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31395       };
31396     } catch (...) {
31397       {
31398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31399       };
31400     }
31401   }
31402 }
31403
31404
31405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31406   int jresult ;
31407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31408   Dali::DrawMode::Type result;
31409
31410   arg1 = (Dali::Actor *)jarg1;
31411   {
31412     try {
31413       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31414     } catch (std::out_of_range& e) {
31415       {
31416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31417       };
31418     } catch (std::exception& e) {
31419       {
31420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31421       };
31422     } catch (...) {
31423       {
31424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31425       };
31426     }
31427   }
31428   jresult = (int)result;
31429   return jresult;
31430 }
31431
31432
31433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31435   bool arg2 ;
31436
31437   arg1 = (Dali::Actor *)jarg1;
31438   arg2 = jarg2 ? true : false;
31439   {
31440     try {
31441       (arg1)->SetSensitive(arg2);
31442     } catch (std::out_of_range& e) {
31443       {
31444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31445       };
31446     } catch (std::exception& e) {
31447       {
31448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31449       };
31450     } catch (...) {
31451       {
31452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31453       };
31454     }
31455   }
31456 }
31457
31458
31459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31460   unsigned int jresult ;
31461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31462   bool result;
31463
31464   arg1 = (Dali::Actor *)jarg1;
31465   {
31466     try {
31467       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31468     } catch (std::out_of_range& e) {
31469       {
31470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31471       };
31472     } catch (std::exception& e) {
31473       {
31474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31475       };
31476     } catch (...) {
31477       {
31478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31479       };
31480     }
31481   }
31482   jresult = result;
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31488   unsigned int jresult ;
31489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31490   float *arg2 = 0 ;
31491   float *arg3 = 0 ;
31492   float arg4 ;
31493   float arg5 ;
31494   bool result;
31495
31496   arg1 = (Dali::Actor *)jarg1;
31497   arg2 = (float *)jarg2;
31498   arg3 = (float *)jarg3;
31499   arg4 = (float)jarg4;
31500   arg5 = (float)jarg5;
31501   {
31502     try {
31503       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31504     } catch (std::out_of_range& e) {
31505       {
31506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31507       };
31508     } catch (std::exception& e) {
31509       {
31510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31511       };
31512     } catch (...) {
31513       {
31514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31515       };
31516     }
31517   }
31518   jresult = result;
31519   return jresult;
31520 }
31521
31522
31523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31525   bool arg2 ;
31526
31527   arg1 = (Dali::Actor *)jarg1;
31528   arg2 = jarg2 ? true : false;
31529   {
31530     try {
31531       (arg1)->SetLeaveRequired(arg2);
31532     } catch (std::out_of_range& e) {
31533       {
31534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31535       };
31536     } catch (std::exception& e) {
31537       {
31538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31539       };
31540     } catch (...) {
31541       {
31542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31543       };
31544     }
31545   }
31546 }
31547
31548
31549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31550   unsigned int jresult ;
31551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31552   bool result;
31553
31554   arg1 = (Dali::Actor *)jarg1;
31555   {
31556     try {
31557       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31558     } catch (std::out_of_range& e) {
31559       {
31560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31561       };
31562     } catch (std::exception& e) {
31563       {
31564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31565       };
31566     } catch (...) {
31567       {
31568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31569       };
31570     }
31571   }
31572   jresult = result;
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31579   bool arg2 ;
31580
31581   arg1 = (Dali::Actor *)jarg1;
31582   arg2 = jarg2 ? true : false;
31583   {
31584     try {
31585       (arg1)->SetKeyboardFocusable(arg2);
31586     } catch (std::out_of_range& e) {
31587       {
31588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31589       };
31590     } catch (std::exception& e) {
31591       {
31592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31593       };
31594     } catch (...) {
31595       {
31596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31597       };
31598     }
31599   }
31600 }
31601
31602
31603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31604   unsigned int jresult ;
31605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31606   bool result;
31607
31608   arg1 = (Dali::Actor *)jarg1;
31609   {
31610     try {
31611       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31612     } catch (std::out_of_range& e) {
31613       {
31614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31615       };
31616     } catch (std::exception& e) {
31617       {
31618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31619       };
31620     } catch (...) {
31621       {
31622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31623       };
31624     }
31625   }
31626   jresult = result;
31627   return jresult;
31628 }
31629
31630
31631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31633   Dali::ResizePolicy::Type arg2 ;
31634   Dali::Dimension::Type arg3 ;
31635
31636   arg1 = (Dali::Actor *)jarg1;
31637   arg2 = (Dali::ResizePolicy::Type)jarg2;
31638   arg3 = (Dali::Dimension::Type)jarg3;
31639   {
31640     try {
31641       (arg1)->SetResizePolicy(arg2,arg3);
31642     } catch (std::out_of_range& e) {
31643       {
31644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31645       };
31646     } catch (std::exception& e) {
31647       {
31648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31649       };
31650     } catch (...) {
31651       {
31652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31653       };
31654     }
31655   }
31656 }
31657
31658
31659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31660   int jresult ;
31661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31662   Dali::Dimension::Type arg2 ;
31663   Dali::ResizePolicy::Type result;
31664
31665   arg1 = (Dali::Actor *)jarg1;
31666   arg2 = (Dali::Dimension::Type)jarg2;
31667   {
31668     try {
31669       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31670     } catch (std::out_of_range& e) {
31671       {
31672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31673       };
31674     } catch (std::exception& e) {
31675       {
31676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31681       };
31682     }
31683   }
31684   jresult = (int)result;
31685   return jresult;
31686 }
31687
31688
31689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31691   Dali::SizeScalePolicy::Type arg2 ;
31692
31693   arg1 = (Dali::Actor *)jarg1;
31694   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31695   {
31696     try {
31697       (arg1)->SetSizeScalePolicy(arg2);
31698     } catch (std::out_of_range& e) {
31699       {
31700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31701       };
31702     } catch (std::exception& e) {
31703       {
31704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31705       };
31706     } catch (...) {
31707       {
31708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31709       };
31710     }
31711   }
31712 }
31713
31714
31715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31716   int jresult ;
31717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31718   Dali::SizeScalePolicy::Type result;
31719
31720   arg1 = (Dali::Actor *)jarg1;
31721   {
31722     try {
31723       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31724     } catch (std::out_of_range& e) {
31725       {
31726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31727       };
31728     } catch (std::exception& e) {
31729       {
31730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31731       };
31732     } catch (...) {
31733       {
31734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31735       };
31736     }
31737   }
31738   jresult = (int)result;
31739   return jresult;
31740 }
31741
31742
31743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31745   Dali::Vector3 *arg2 = 0 ;
31746
31747   arg1 = (Dali::Actor *)jarg1;
31748   arg2 = (Dali::Vector3 *)jarg2;
31749   if (!arg2) {
31750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31751     return ;
31752   }
31753   {
31754     try {
31755       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31756     } catch (std::out_of_range& e) {
31757       {
31758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31759       };
31760     } catch (std::exception& e) {
31761       {
31762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31763       };
31764     } catch (...) {
31765       {
31766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31767       };
31768     }
31769   }
31770 }
31771
31772
31773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31774   void * jresult ;
31775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31776   Dali::Vector3 result;
31777
31778   arg1 = (Dali::Actor *)jarg1;
31779   {
31780     try {
31781       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31782     } catch (std::out_of_range& e) {
31783       {
31784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31785       };
31786     } catch (std::exception& e) {
31787       {
31788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31789       };
31790     } catch (...) {
31791       {
31792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31793       };
31794     }
31795   }
31796   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31797   return jresult;
31798 }
31799
31800
31801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31802   float jresult ;
31803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31804   float arg2 ;
31805   float result;
31806
31807   arg1 = (Dali::Actor *)jarg1;
31808   arg2 = (float)jarg2;
31809   {
31810     try {
31811       result = (float)(arg1)->GetHeightForWidth(arg2);
31812     } catch (std::out_of_range& e) {
31813       {
31814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31815       };
31816     } catch (std::exception& e) {
31817       {
31818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31819       };
31820     } catch (...) {
31821       {
31822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31823       };
31824     }
31825   }
31826   jresult = result;
31827   return jresult;
31828 }
31829
31830
31831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31832   float jresult ;
31833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31834   float arg2 ;
31835   float result;
31836
31837   arg1 = (Dali::Actor *)jarg1;
31838   arg2 = (float)jarg2;
31839   {
31840     try {
31841       result = (float)(arg1)->GetWidthForHeight(arg2);
31842     } catch (std::out_of_range& e) {
31843       {
31844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31845       };
31846     } catch (std::exception& e) {
31847       {
31848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31849       };
31850     } catch (...) {
31851       {
31852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31853       };
31854     }
31855   }
31856   jresult = result;
31857   return jresult;
31858 }
31859
31860
31861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31862   float jresult ;
31863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31864   Dali::Dimension::Type arg2 ;
31865   float result;
31866
31867   arg1 = (Dali::Actor *)jarg1;
31868   arg2 = (Dali::Dimension::Type)jarg2;
31869   {
31870     try {
31871       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31872     } catch (std::out_of_range& e) {
31873       {
31874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (std::exception& e) {
31877       {
31878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886   jresult = result;
31887   return jresult;
31888 }
31889
31890
31891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31893   Dali::Padding *arg2 = 0 ;
31894
31895   arg1 = (Dali::Actor *)jarg1;
31896   arg2 = (Dali::Padding *)jarg2;
31897   if (!arg2) {
31898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31899     return ;
31900   }
31901   {
31902     try {
31903       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31904     } catch (std::out_of_range& e) {
31905       {
31906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31907       };
31908     } catch (std::exception& e) {
31909       {
31910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31911       };
31912     } catch (...) {
31913       {
31914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31915       };
31916     }
31917   }
31918 }
31919
31920
31921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31923   Dali::Padding *arg2 = 0 ;
31924
31925   arg1 = (Dali::Actor *)jarg1;
31926   arg2 = (Dali::Padding *)jarg2;
31927   if (!arg2) {
31928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31929     return ;
31930   }
31931   {
31932     try {
31933       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31934     } catch (std::out_of_range& e) {
31935       {
31936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31937       };
31938     } catch (std::exception& e) {
31939       {
31940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31941       };
31942     } catch (...) {
31943       {
31944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31945       };
31946     }
31947   }
31948 }
31949
31950
31951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31953   Dali::Vector2 *arg2 = 0 ;
31954
31955   arg1 = (Dali::Actor *)jarg1;
31956   arg2 = (Dali::Vector2 *)jarg2;
31957   if (!arg2) {
31958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31959     return ;
31960   }
31961   {
31962     try {
31963       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31964     } catch (std::out_of_range& e) {
31965       {
31966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31967       };
31968     } catch (std::exception& e) {
31969       {
31970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31971       };
31972     } catch (...) {
31973       {
31974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31975       };
31976     }
31977   }
31978 }
31979
31980
31981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31982   void * jresult ;
31983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31984   Dali::Vector2 result;
31985
31986   arg1 = (Dali::Actor *)jarg1;
31987   {
31988     try {
31989       result = (arg1)->GetMinimumSize();
31990     } catch (std::out_of_range& e) {
31991       {
31992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31993       };
31994     } catch (std::exception& e) {
31995       {
31996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31997       };
31998     } catch (...) {
31999       {
32000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32001       };
32002     }
32003   }
32004   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32005   return jresult;
32006 }
32007
32008
32009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32011   Dali::Vector2 *arg2 = 0 ;
32012
32013   arg1 = (Dali::Actor *)jarg1;
32014   arg2 = (Dali::Vector2 *)jarg2;
32015   if (!arg2) {
32016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32017     return ;
32018   }
32019   {
32020     try {
32021       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32022     } catch (std::out_of_range& e) {
32023       {
32024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32025       };
32026     } catch (std::exception& e) {
32027       {
32028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32029       };
32030     } catch (...) {
32031       {
32032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32033       };
32034     }
32035   }
32036 }
32037
32038
32039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32040   void * jresult ;
32041   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32042   Dali::Vector2 result;
32043
32044   arg1 = (Dali::Actor *)jarg1;
32045   {
32046     try {
32047       result = (arg1)->GetMaximumSize();
32048     } catch (std::out_of_range& e) {
32049       {
32050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32051       };
32052     } catch (std::exception& e) {
32053       {
32054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32055       };
32056     } catch (...) {
32057       {
32058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32059       };
32060     }
32061   }
32062   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32063   return jresult;
32064 }
32065
32066
32067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32068   int jresult ;
32069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32070   int result;
32071
32072   arg1 = (Dali::Actor *)jarg1;
32073   {
32074     try {
32075       result = (int)(arg1)->GetHierarchyDepth();
32076     } catch (std::out_of_range& e) {
32077       {
32078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32079       };
32080     } catch (std::exception& e) {
32081       {
32082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32083       };
32084     } catch (...) {
32085       {
32086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32087       };
32088     }
32089   }
32090   jresult = result;
32091   return jresult;
32092 }
32093
32094
32095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32096   unsigned int jresult ;
32097   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32098   Dali::Renderer *arg2 = 0 ;
32099   unsigned int result;
32100
32101   arg1 = (Dali::Actor *)jarg1;
32102   arg2 = (Dali::Renderer *)jarg2;
32103   if (!arg2) {
32104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32105     return 0;
32106   }
32107   {
32108     try {
32109       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32110     } catch (std::out_of_range& e) {
32111       {
32112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32113       };
32114     } catch (std::exception& e) {
32115       {
32116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32117       };
32118     } catch (...) {
32119       {
32120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32121       };
32122     }
32123   }
32124   jresult = result;
32125   return jresult;
32126 }
32127
32128
32129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32130   unsigned int jresult ;
32131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32132   unsigned int result;
32133
32134   arg1 = (Dali::Actor *)jarg1;
32135   {
32136     try {
32137       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32138     } catch (std::out_of_range& e) {
32139       {
32140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32141       };
32142     } catch (std::exception& e) {
32143       {
32144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32145       };
32146     } catch (...) {
32147       {
32148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32149       };
32150     }
32151   }
32152   jresult = result;
32153   return jresult;
32154 }
32155
32156
32157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32158   void * jresult ;
32159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32160   unsigned int arg2 ;
32161   Dali::Renderer result;
32162
32163   arg1 = (Dali::Actor *)jarg1;
32164   arg2 = (unsigned int)jarg2;
32165   {
32166     try {
32167       result = (arg1)->GetRendererAt(arg2);
32168     } catch (std::out_of_range& e) {
32169       {
32170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32171       };
32172     } catch (std::exception& e) {
32173       {
32174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32175       };
32176     } catch (...) {
32177       {
32178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32179       };
32180     }
32181   }
32182   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32183   return jresult;
32184 }
32185
32186
32187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32189   Dali::Renderer *arg2 = 0 ;
32190
32191   arg1 = (Dali::Actor *)jarg1;
32192   arg2 = (Dali::Renderer *)jarg2;
32193   if (!arg2) {
32194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32195     return ;
32196   }
32197   {
32198     try {
32199       (arg1)->RemoveRenderer(*arg2);
32200     } catch (std::out_of_range& e) {
32201       {
32202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32203       };
32204     } catch (std::exception& e) {
32205       {
32206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32207       };
32208     } catch (...) {
32209       {
32210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32211       };
32212     }
32213   }
32214 }
32215
32216
32217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32219   unsigned int arg2 ;
32220
32221   arg1 = (Dali::Actor *)jarg1;
32222   arg2 = (unsigned int)jarg2;
32223   {
32224     try {
32225       (arg1)->RemoveRenderer(arg2);
32226     } catch (std::out_of_range& e) {
32227       {
32228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32229       };
32230     } catch (std::exception& e) {
32231       {
32232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32233       };
32234     } catch (...) {
32235       {
32236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32237       };
32238     }
32239   }
32240 }
32241
32242
32243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32244   void * jresult ;
32245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32246   Dali::Actor::TouchSignalType *result = 0 ;
32247
32248   arg1 = (Dali::Actor *)jarg1;
32249   {
32250     try {
32251       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32252     } catch (std::out_of_range& e) {
32253       {
32254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (std::exception& e) {
32257       {
32258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32259       };
32260     } catch (...) {
32261       {
32262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32263       };
32264     }
32265   }
32266   jresult = (void *)result;
32267   return jresult;
32268 }
32269
32270
32271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32272   void * jresult ;
32273   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32274   Dali::Actor::TouchDataSignalType *result = 0 ;
32275
32276   arg1 = (Dali::Actor *)jarg1;
32277   {
32278     try {
32279       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32280     } catch (std::out_of_range& e) {
32281       {
32282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32283       };
32284     } catch (std::exception& e) {
32285       {
32286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32287       };
32288     } catch (...) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32291       };
32292     }
32293   }
32294   jresult = (void *)result;
32295   return jresult;
32296 }
32297
32298
32299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32300   void * jresult ;
32301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32302   Dali::Actor::HoverSignalType *result = 0 ;
32303
32304   arg1 = (Dali::Actor *)jarg1;
32305   {
32306     try {
32307       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32308     } catch (std::out_of_range& e) {
32309       {
32310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32311       };
32312     } catch (std::exception& e) {
32313       {
32314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32315       };
32316     } catch (...) {
32317       {
32318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32319       };
32320     }
32321   }
32322   jresult = (void *)result;
32323   return jresult;
32324 }
32325
32326
32327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32328   void * jresult ;
32329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32330   Dali::Actor::WheelEventSignalType *result = 0 ;
32331
32332   arg1 = (Dali::Actor *)jarg1;
32333   {
32334     try {
32335       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32336     } catch (std::out_of_range& e) {
32337       {
32338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32339       };
32340     } catch (std::exception& e) {
32341       {
32342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32343       };
32344     } catch (...) {
32345       {
32346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32347       };
32348     }
32349   }
32350   jresult = (void *)result;
32351   return jresult;
32352 }
32353
32354
32355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32356   void * jresult ;
32357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32358   Dali::Actor::OnStageSignalType *result = 0 ;
32359
32360   arg1 = (Dali::Actor *)jarg1;
32361   {
32362     try {
32363       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32364     } catch (std::out_of_range& e) {
32365       {
32366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32367       };
32368     } catch (std::exception& e) {
32369       {
32370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32371       };
32372     } catch (...) {
32373       {
32374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32375       };
32376     }
32377   }
32378   jresult = (void *)result;
32379   return jresult;
32380 }
32381
32382
32383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32384   void * jresult ;
32385   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32386   Dali::Actor::OffStageSignalType *result = 0 ;
32387
32388   arg1 = (Dali::Actor *)jarg1;
32389   {
32390     try {
32391       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32392     } catch (std::out_of_range& e) {
32393       {
32394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32395       };
32396     } catch (std::exception& e) {
32397       {
32398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32399       };
32400     } catch (...) {
32401       {
32402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32403       };
32404     }
32405   }
32406   jresult = (void *)result;
32407   return jresult;
32408 }
32409
32410
32411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32412   void * jresult ;
32413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32414   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32415
32416   arg1 = (Dali::Actor *)jarg1;
32417   {
32418     try {
32419       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32420     } catch (std::out_of_range& e) {
32421       {
32422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32423       };
32424     } catch (std::exception& e) {
32425       {
32426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32427       };
32428     } catch (...) {
32429       {
32430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32431       };
32432     }
32433   }
32434   jresult = (void *)result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32440   Dali::Actor *arg1 = 0 ;
32441
32442   arg1 = (Dali::Actor *)jarg1;
32443   if (!arg1) {
32444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32445     return ;
32446   }
32447   {
32448     try {
32449       Dali::UnparentAndReset(*arg1);
32450     } catch (std::out_of_range& e) {
32451       {
32452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32453       };
32454     } catch (std::exception& e) {
32455       {
32456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32457       };
32458     } catch (...) {
32459       {
32460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32461       };
32462     }
32463   }
32464 }
32465
32466
32467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32468   int jresult ;
32469   int result;
32470
32471   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32472   jresult = (int)result;
32473   return jresult;
32474 }
32475
32476
32477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32478   int jresult ;
32479   int result;
32480
32481   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32482   jresult = (int)result;
32483   return jresult;
32484 }
32485
32486
32487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32488   int jresult ;
32489   int result;
32490
32491   result = (int)Dali::Layer::Property::BEHAVIOR;
32492   jresult = (int)result;
32493   return jresult;
32494 }
32495
32496
32497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32498   void * jresult ;
32499   Dali::Layer::Property *result = 0 ;
32500
32501   {
32502     try {
32503       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32504     } catch (std::out_of_range& e) {
32505       {
32506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32507       };
32508     } catch (std::exception& e) {
32509       {
32510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32511       };
32512     } catch (...) {
32513       {
32514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32515       };
32516     }
32517   }
32518   jresult = (void *)result;
32519   return jresult;
32520 }
32521
32522
32523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32524   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32525
32526   arg1 = (Dali::Layer::Property *)jarg1;
32527   {
32528     try {
32529       delete arg1;
32530     } catch (std::out_of_range& e) {
32531       {
32532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32533       };
32534     } catch (std::exception& e) {
32535       {
32536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32537       };
32538     } catch (...) {
32539       {
32540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32541       };
32542     }
32543   }
32544 }
32545
32546
32547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32548   void * jresult ;
32549   Dali::Layer *result = 0 ;
32550
32551   {
32552     try {
32553       result = (Dali::Layer *)new Dali::Layer();
32554     } catch (std::out_of_range& e) {
32555       {
32556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32557       };
32558     } catch (std::exception& e) {
32559       {
32560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32561       };
32562     } catch (...) {
32563       {
32564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32565       };
32566     }
32567   }
32568   jresult = (void *)result;
32569   return jresult;
32570 }
32571
32572
32573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32574   void * jresult ;
32575   Dali::Layer result;
32576
32577   {
32578     try {
32579       result = Dali::Layer::New();
32580     } catch (std::out_of_range& e) {
32581       {
32582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32583       };
32584     } catch (std::exception& e) {
32585       {
32586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32587       };
32588     } catch (...) {
32589       {
32590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32591       };
32592     }
32593   }
32594   jresult = new Dali::Layer((const Dali::Layer &)result);
32595   return jresult;
32596 }
32597
32598
32599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32600   void * jresult ;
32601   Dali::BaseHandle arg1 ;
32602   Dali::BaseHandle *argp1 ;
32603   Dali::Layer result;
32604
32605   argp1 = (Dali::BaseHandle *)jarg1;
32606   if (!argp1) {
32607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32608     return 0;
32609   }
32610   arg1 = *argp1;
32611   {
32612     try {
32613       result = Dali::Layer::DownCast(arg1);
32614     } catch (std::out_of_range& e) {
32615       {
32616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32617       };
32618     } catch (std::exception& e) {
32619       {
32620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32621       };
32622     } catch (...) {
32623       {
32624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32625       };
32626     }
32627   }
32628   jresult = new Dali::Layer((const Dali::Layer &)result);
32629   return jresult;
32630 }
32631
32632
32633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32634   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32635
32636   arg1 = (Dali::Layer *)jarg1;
32637   {
32638     try {
32639       delete arg1;
32640     } catch (std::out_of_range& e) {
32641       {
32642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32643       };
32644     } catch (std::exception& e) {
32645       {
32646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32647       };
32648     } catch (...) {
32649       {
32650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32651       };
32652     }
32653   }
32654 }
32655
32656
32657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32658   void * jresult ;
32659   Dali::Layer *arg1 = 0 ;
32660   Dali::Layer *result = 0 ;
32661
32662   arg1 = (Dali::Layer *)jarg1;
32663   if (!arg1) {
32664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32665     return 0;
32666   }
32667   {
32668     try {
32669       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32670     } catch (std::out_of_range& e) {
32671       {
32672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32673       };
32674     } catch (std::exception& e) {
32675       {
32676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32677       };
32678     } catch (...) {
32679       {
32680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32681       };
32682     }
32683   }
32684   jresult = (void *)result;
32685   return jresult;
32686 }
32687
32688
32689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32690   void * jresult ;
32691   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32692   Dali::Layer *arg2 = 0 ;
32693   Dali::Layer *result = 0 ;
32694
32695   arg1 = (Dali::Layer *)jarg1;
32696   arg2 = (Dali::Layer *)jarg2;
32697   if (!arg2) {
32698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32699     return 0;
32700   }
32701   {
32702     try {
32703       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32704     } catch (std::out_of_range& e) {
32705       {
32706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32707       };
32708     } catch (std::exception& e) {
32709       {
32710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32711       };
32712     } catch (...) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32715       };
32716     }
32717   }
32718   jresult = (void *)result;
32719   return jresult;
32720 }
32721
32722
32723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32724   unsigned int jresult ;
32725   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32726   unsigned int result;
32727
32728   arg1 = (Dali::Layer *)jarg1;
32729   {
32730     try {
32731       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32732     } catch (std::out_of_range& e) {
32733       {
32734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32735       };
32736     } catch (std::exception& e) {
32737       {
32738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32739       };
32740     } catch (...) {
32741       {
32742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32743       };
32744     }
32745   }
32746   jresult = result;
32747   return jresult;
32748 }
32749
32750
32751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32752   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32753
32754   arg1 = (Dali::Layer *)jarg1;
32755   {
32756     try {
32757       (arg1)->Raise();
32758     } catch (std::out_of_range& e) {
32759       {
32760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32761       };
32762     } catch (std::exception& e) {
32763       {
32764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32765       };
32766     } catch (...) {
32767       {
32768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32769       };
32770     }
32771   }
32772 }
32773
32774
32775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32776   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32777
32778   arg1 = (Dali::Layer *)jarg1;
32779   {
32780     try {
32781       (arg1)->Lower();
32782     } catch (std::out_of_range& e) {
32783       {
32784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32785       };
32786     } catch (std::exception& e) {
32787       {
32788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32789       };
32790     } catch (...) {
32791       {
32792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32793       };
32794     }
32795   }
32796 }
32797
32798
32799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32800   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32801   Dali::Layer arg2 ;
32802   Dali::Layer *argp2 ;
32803
32804   arg1 = (Dali::Layer *)jarg1;
32805   argp2 = (Dali::Layer *)jarg2;
32806   if (!argp2) {
32807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32808     return ;
32809   }
32810   arg2 = *argp2;
32811   {
32812     try {
32813       (arg1)->RaiseAbove(arg2);
32814     } catch (std::out_of_range& e) {
32815       {
32816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32817       };
32818     } catch (std::exception& e) {
32819       {
32820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32821       };
32822     } catch (...) {
32823       {
32824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32825       };
32826     }
32827   }
32828 }
32829
32830
32831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32832   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32833   Dali::Layer arg2 ;
32834   Dali::Layer *argp2 ;
32835
32836   arg1 = (Dali::Layer *)jarg1;
32837   argp2 = (Dali::Layer *)jarg2;
32838   if (!argp2) {
32839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32840     return ;
32841   }
32842   arg2 = *argp2;
32843   {
32844     try {
32845       (arg1)->LowerBelow(arg2);
32846     } catch (std::out_of_range& e) {
32847       {
32848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32849       };
32850     } catch (std::exception& e) {
32851       {
32852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32853       };
32854     } catch (...) {
32855       {
32856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32857       };
32858     }
32859   }
32860 }
32861
32862
32863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32864   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32865
32866   arg1 = (Dali::Layer *)jarg1;
32867   {
32868     try {
32869       (arg1)->RaiseToTop();
32870     } catch (std::out_of_range& e) {
32871       {
32872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32873       };
32874     } catch (std::exception& e) {
32875       {
32876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32877       };
32878     } catch (...) {
32879       {
32880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32881       };
32882     }
32883   }
32884 }
32885
32886
32887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32888   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32889
32890   arg1 = (Dali::Layer *)jarg1;
32891   {
32892     try {
32893       (arg1)->LowerToBottom();
32894     } catch (std::out_of_range& e) {
32895       {
32896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32897       };
32898     } catch (std::exception& e) {
32899       {
32900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32901       };
32902     } catch (...) {
32903       {
32904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32905       };
32906     }
32907   }
32908 }
32909
32910
32911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32912   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32913   Dali::Layer arg2 ;
32914   Dali::Layer *argp2 ;
32915
32916   arg1 = (Dali::Layer *)jarg1;
32917   argp2 = (Dali::Layer *)jarg2;
32918   if (!argp2) {
32919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32920     return ;
32921   }
32922   arg2 = *argp2;
32923   {
32924     try {
32925       (arg1)->MoveAbove(arg2);
32926     } catch (std::out_of_range& e) {
32927       {
32928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32929       };
32930     } catch (std::exception& e) {
32931       {
32932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32933       };
32934     } catch (...) {
32935       {
32936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32937       };
32938     }
32939   }
32940 }
32941
32942
32943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32944   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32945   Dali::Layer arg2 ;
32946   Dali::Layer *argp2 ;
32947
32948   arg1 = (Dali::Layer *)jarg1;
32949   argp2 = (Dali::Layer *)jarg2;
32950   if (!argp2) {
32951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32952     return ;
32953   }
32954   arg2 = *argp2;
32955   {
32956     try {
32957       (arg1)->MoveBelow(arg2);
32958     } catch (std::out_of_range& e) {
32959       {
32960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32961       };
32962     } catch (std::exception& e) {
32963       {
32964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32965       };
32966     } catch (...) {
32967       {
32968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32969       };
32970     }
32971   }
32972 }
32973
32974
32975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32976   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32977   Dali::Layer::Behavior arg2 ;
32978
32979   arg1 = (Dali::Layer *)jarg1;
32980   arg2 = (Dali::Layer::Behavior)jarg2;
32981   {
32982     try {
32983       (arg1)->SetBehavior(arg2);
32984     } catch (std::out_of_range& e) {
32985       {
32986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32987       };
32988     } catch (std::exception& e) {
32989       {
32990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32991       };
32992     } catch (...) {
32993       {
32994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32995       };
32996     }
32997   }
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33002   int jresult ;
33003   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33004   Dali::Layer::Behavior result;
33005
33006   arg1 = (Dali::Layer *)jarg1;
33007   {
33008     try {
33009       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33010     } catch (std::out_of_range& e) {
33011       {
33012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33013       };
33014     } catch (std::exception& e) {
33015       {
33016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33017       };
33018     } catch (...) {
33019       {
33020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33021       };
33022     }
33023   }
33024   jresult = (int)result;
33025   return jresult;
33026 }
33027
33028
33029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33030   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33031   bool arg2 ;
33032
33033   arg1 = (Dali::Layer *)jarg1;
33034   arg2 = jarg2 ? true : false;
33035   {
33036     try {
33037       (arg1)->SetClipping(arg2);
33038     } catch (std::out_of_range& e) {
33039       {
33040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33041       };
33042     } catch (std::exception& e) {
33043       {
33044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33045       };
33046     } catch (...) {
33047       {
33048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33049       };
33050     }
33051   }
33052 }
33053
33054
33055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33056   unsigned int jresult ;
33057   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33058   bool result;
33059
33060   arg1 = (Dali::Layer *)jarg1;
33061   {
33062     try {
33063       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33064     } catch (std::out_of_range& e) {
33065       {
33066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33067       };
33068     } catch (std::exception& e) {
33069       {
33070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33071       };
33072     } catch (...) {
33073       {
33074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33075       };
33076     }
33077   }
33078   jresult = result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33084   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33085   int arg2 ;
33086   int arg3 ;
33087   int arg4 ;
33088   int arg5 ;
33089
33090   arg1 = (Dali::Layer *)jarg1;
33091   arg2 = (int)jarg2;
33092   arg3 = (int)jarg3;
33093   arg4 = (int)jarg4;
33094   arg5 = (int)jarg5;
33095   {
33096     try {
33097       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33098     } catch (std::out_of_range& e) {
33099       {
33100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33101       };
33102     } catch (std::exception& e) {
33103       {
33104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33105       };
33106     } catch (...) {
33107       {
33108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33109       };
33110     }
33111   }
33112 }
33113
33114
33115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33116   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33117   Dali::ClippingBox arg2 ;
33118   Dali::ClippingBox *argp2 ;
33119
33120   arg1 = (Dali::Layer *)jarg1;
33121   argp2 = (Dali::ClippingBox *)jarg2;
33122   if (!argp2) {
33123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33124     return ;
33125   }
33126   arg2 = *argp2;
33127   {
33128     try {
33129       (arg1)->SetClippingBox(arg2);
33130     } catch (std::out_of_range& e) {
33131       {
33132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33133       };
33134     } catch (std::exception& e) {
33135       {
33136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33137       };
33138     } catch (...) {
33139       {
33140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33141       };
33142     }
33143   }
33144 }
33145
33146
33147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33148   void * jresult ;
33149   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33150   Dali::ClippingBox result;
33151
33152   arg1 = (Dali::Layer *)jarg1;
33153   {
33154     try {
33155       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33156     } catch (std::out_of_range& e) {
33157       {
33158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33159       };
33160     } catch (std::exception& e) {
33161       {
33162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33163       };
33164     } catch (...) {
33165       {
33166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33167       };
33168     }
33169   }
33170   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33171   return jresult;
33172 }
33173
33174
33175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33176   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33177   bool arg2 ;
33178
33179   arg1 = (Dali::Layer *)jarg1;
33180   arg2 = jarg2 ? true : false;
33181   {
33182     try {
33183       (arg1)->SetDepthTestDisabled(arg2);
33184     } catch (std::out_of_range& e) {
33185       {
33186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33187       };
33188     } catch (std::exception& e) {
33189       {
33190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33191       };
33192     } catch (...) {
33193       {
33194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33195       };
33196     }
33197   }
33198 }
33199
33200
33201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33202   unsigned int jresult ;
33203   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33204   bool result;
33205
33206   arg1 = (Dali::Layer *)jarg1;
33207   {
33208     try {
33209       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33210     } catch (std::out_of_range& e) {
33211       {
33212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33213       };
33214     } catch (std::exception& e) {
33215       {
33216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33217       };
33218     } catch (...) {
33219       {
33220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33221       };
33222     }
33223   }
33224   jresult = result;
33225   return jresult;
33226 }
33227
33228
33229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33230   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33231   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33232
33233   arg1 = (Dali::Layer *)jarg1;
33234   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33235   {
33236     try {
33237       (arg1)->SetSortFunction(arg2);
33238     } catch (std::out_of_range& e) {
33239       {
33240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33241       };
33242     } catch (std::exception& e) {
33243       {
33244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33245       };
33246     } catch (...) {
33247       {
33248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33249       };
33250     }
33251   }
33252 }
33253
33254
33255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33256   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33257   bool arg2 ;
33258
33259   arg1 = (Dali::Layer *)jarg1;
33260   arg2 = jarg2 ? true : false;
33261   {
33262     try {
33263       (arg1)->SetTouchConsumed(arg2);
33264     } catch (std::out_of_range& e) {
33265       {
33266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33267       };
33268     } catch (std::exception& e) {
33269       {
33270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33271       };
33272     } catch (...) {
33273       {
33274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33275       };
33276     }
33277   }
33278 }
33279
33280
33281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33282   unsigned int jresult ;
33283   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33284   bool result;
33285
33286   arg1 = (Dali::Layer *)jarg1;
33287   {
33288     try {
33289       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33290     } catch (std::out_of_range& e) {
33291       {
33292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33293       };
33294     } catch (std::exception& e) {
33295       {
33296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33297       };
33298     } catch (...) {
33299       {
33300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33301       };
33302     }
33303   }
33304   jresult = result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33310   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33311   bool arg2 ;
33312
33313   arg1 = (Dali::Layer *)jarg1;
33314   arg2 = jarg2 ? true : false;
33315   {
33316     try {
33317       (arg1)->SetHoverConsumed(arg2);
33318     } catch (std::out_of_range& e) {
33319       {
33320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33321       };
33322     } catch (std::exception& e) {
33323       {
33324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33325       };
33326     } catch (...) {
33327       {
33328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33329       };
33330     }
33331   }
33332 }
33333
33334
33335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33336   unsigned int jresult ;
33337   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33338   bool result;
33339
33340   arg1 = (Dali::Layer *)jarg1;
33341   {
33342     try {
33343       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33344     } catch (std::out_of_range& e) {
33345       {
33346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33347       };
33348     } catch (std::exception& e) {
33349       {
33350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33351       };
33352     } catch (...) {
33353       {
33354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33355       };
33356     }
33357   }
33358   jresult = result;
33359   return jresult;
33360 }
33361
33362
33363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33364   void * jresult ;
33365   Dali::Vector4 *result = 0 ;
33366
33367   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33368   jresult = (void *)result;
33369   return jresult;
33370 }
33371
33372
33373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33374   void * jresult ;
33375   Dali::Vector4 *result = 0 ;
33376
33377   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33378   jresult = (void *)result;
33379   return jresult;
33380 }
33381
33382
33383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33384   void * jresult ;
33385   Dali::Stage *result = 0 ;
33386
33387   {
33388     try {
33389       result = (Dali::Stage *)new Dali::Stage();
33390     } catch (std::out_of_range& e) {
33391       {
33392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33393       };
33394     } catch (std::exception& e) {
33395       {
33396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33397       };
33398     } catch (...) {
33399       {
33400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33401       };
33402     }
33403   }
33404   jresult = (void *)result;
33405   return jresult;
33406 }
33407
33408
33409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33410   void * jresult ;
33411   Dali::Stage result;
33412
33413   {
33414     try {
33415       result = Dali::Stage::GetCurrent();
33416     } catch (std::out_of_range& e) {
33417       {
33418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33419       };
33420     } catch (std::exception& e) {
33421       {
33422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33423       };
33424     } catch (...) {
33425       {
33426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33427       };
33428     }
33429   }
33430   jresult = new Dali::Stage((const Dali::Stage &)result);
33431   return jresult;
33432 }
33433
33434
33435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33436   unsigned int jresult ;
33437   bool result;
33438
33439   {
33440     try {
33441       result = (bool)Dali::Stage::IsInstalled();
33442     } catch (std::out_of_range& e) {
33443       {
33444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33445       };
33446     } catch (std::exception& e) {
33447       {
33448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33449       };
33450     } catch (...) {
33451       {
33452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33453       };
33454     }
33455   }
33456   jresult = result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33462   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33463
33464   arg1 = (Dali::Stage *)jarg1;
33465   {
33466     try {
33467       delete arg1;
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33475       };
33476     } catch (...) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33479       };
33480     }
33481   }
33482 }
33483
33484
33485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33486   void * jresult ;
33487   Dali::Stage *arg1 = 0 ;
33488   Dali::Stage *result = 0 ;
33489
33490   arg1 = (Dali::Stage *)jarg1;
33491   if (!arg1) {
33492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33493     return 0;
33494   }
33495   {
33496     try {
33497       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33498     } catch (std::out_of_range& e) {
33499       {
33500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33501       };
33502     } catch (std::exception& e) {
33503       {
33504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33505       };
33506     } catch (...) {
33507       {
33508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33509       };
33510     }
33511   }
33512   jresult = (void *)result;
33513   return jresult;
33514 }
33515
33516
33517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33518   void * jresult ;
33519   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33520   Dali::Stage *arg2 = 0 ;
33521   Dali::Stage *result = 0 ;
33522
33523   arg1 = (Dali::Stage *)jarg1;
33524   arg2 = (Dali::Stage *)jarg2;
33525   if (!arg2) {
33526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33527     return 0;
33528   }
33529   {
33530     try {
33531       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33532     } catch (std::out_of_range& e) {
33533       {
33534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (std::exception& e) {
33537       {
33538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33539       };
33540     } catch (...) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33543       };
33544     }
33545   }
33546   jresult = (void *)result;
33547   return jresult;
33548 }
33549
33550
33551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33552   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33553   Dali::Actor *arg2 = 0 ;
33554
33555   arg1 = (Dali::Stage *)jarg1;
33556   arg2 = (Dali::Actor *)jarg2;
33557   if (!arg2) {
33558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33559     return ;
33560   }
33561   {
33562     try {
33563       (arg1)->Add(*arg2);
33564     } catch (std::out_of_range& e) {
33565       {
33566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33567       };
33568     } catch (std::exception& e) {
33569       {
33570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33571       };
33572     } catch (...) {
33573       {
33574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33575       };
33576     }
33577   }
33578 }
33579
33580
33581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33582   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33583   Dali::Actor *arg2 = 0 ;
33584
33585   arg1 = (Dali::Stage *)jarg1;
33586   arg2 = (Dali::Actor *)jarg2;
33587   if (!arg2) {
33588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33589     return ;
33590   }
33591   {
33592     try {
33593       (arg1)->Remove(*arg2);
33594     } catch (std::out_of_range& e) {
33595       {
33596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33597       };
33598     } catch (std::exception& e) {
33599       {
33600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33601       };
33602     } catch (...) {
33603       {
33604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33605       };
33606     }
33607   }
33608 }
33609
33610
33611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33612   void * jresult ;
33613   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33614   Dali::Vector2 result;
33615
33616   arg1 = (Dali::Stage *)jarg1;
33617   {
33618     try {
33619       result = ((Dali::Stage const *)arg1)->GetSize();
33620     } catch (std::out_of_range& e) {
33621       {
33622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33623       };
33624     } catch (std::exception& e) {
33625       {
33626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33627       };
33628     } catch (...) {
33629       {
33630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33631       };
33632     }
33633   }
33634   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33635   return jresult;
33636 }
33637
33638
33639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33640   void * jresult ;
33641   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33642   Dali::RenderTaskList result;
33643
33644   arg1 = (Dali::Stage *)jarg1;
33645   {
33646     try {
33647       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33648     } catch (std::out_of_range& e) {
33649       {
33650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33651       };
33652     } catch (std::exception& e) {
33653       {
33654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33655       };
33656     } catch (...) {
33657       {
33658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33659       };
33660     }
33661   }
33662   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33663   return jresult;
33664 }
33665
33666
33667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33668   unsigned int jresult ;
33669   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33670   unsigned int result;
33671
33672   arg1 = (Dali::Stage *)jarg1;
33673   {
33674     try {
33675       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33676     } catch (std::out_of_range& e) {
33677       {
33678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33679       };
33680     } catch (std::exception& e) {
33681       {
33682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33683       };
33684     } catch (...) {
33685       {
33686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33687       };
33688     }
33689   }
33690   jresult = result;
33691   return jresult;
33692 }
33693
33694
33695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33696   void * jresult ;
33697   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33698   unsigned int arg2 ;
33699   Dali::Layer result;
33700
33701   arg1 = (Dali::Stage *)jarg1;
33702   arg2 = (unsigned int)jarg2;
33703   {
33704     try {
33705       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33706     } catch (std::out_of_range& e) {
33707       {
33708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33709       };
33710     } catch (std::exception& e) {
33711       {
33712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33713       };
33714     } catch (...) {
33715       {
33716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33717       };
33718     }
33719   }
33720   jresult = new Dali::Layer((const Dali::Layer &)result);
33721   return jresult;
33722 }
33723
33724
33725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33726   void * jresult ;
33727   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33728   Dali::Layer result;
33729
33730   arg1 = (Dali::Stage *)jarg1;
33731   {
33732     try {
33733       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33734     } catch (std::out_of_range& e) {
33735       {
33736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33737       };
33738     } catch (std::exception& e) {
33739       {
33740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33741       };
33742     } catch (...) {
33743       {
33744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33745       };
33746     }
33747   }
33748   jresult = new Dali::Layer((const Dali::Layer &)result);
33749   return jresult;
33750 }
33751
33752
33753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33754   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33755   Dali::Vector4 arg2 ;
33756   Dali::Vector4 *argp2 ;
33757
33758   arg1 = (Dali::Stage *)jarg1;
33759   argp2 = (Dali::Vector4 *)jarg2;
33760   if (!argp2) {
33761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33762     return ;
33763   }
33764   arg2 = *argp2;
33765   {
33766     try {
33767       (arg1)->SetBackgroundColor(arg2);
33768     } catch (std::out_of_range& e) {
33769       {
33770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33771       };
33772     } catch (std::exception& e) {
33773       {
33774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33775       };
33776     } catch (...) {
33777       {
33778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33779       };
33780     }
33781   }
33782 }
33783
33784
33785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33786   void * jresult ;
33787   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33788   Dali::Vector4 result;
33789
33790   arg1 = (Dali::Stage *)jarg1;
33791   {
33792     try {
33793       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33794     } catch (std::out_of_range& e) {
33795       {
33796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33797       };
33798     } catch (std::exception& e) {
33799       {
33800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33801       };
33802     } catch (...) {
33803       {
33804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33805       };
33806     }
33807   }
33808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33809   return jresult;
33810 }
33811
33812
33813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33814   void * jresult ;
33815   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33816   Dali::Vector2 result;
33817
33818   arg1 = (Dali::Stage *)jarg1;
33819   {
33820     try {
33821       result = ((Dali::Stage const *)arg1)->GetDpi();
33822     } catch (std::out_of_range& e) {
33823       {
33824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (std::exception& e) {
33827       {
33828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33829       };
33830     } catch (...) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33833       };
33834     }
33835   }
33836   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33837   return jresult;
33838 }
33839
33840
33841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33842   void * jresult ;
33843   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33844   Dali::ObjectRegistry result;
33845
33846   arg1 = (Dali::Stage *)jarg1;
33847   {
33848     try {
33849       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (...) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33861       };
33862     }
33863   }
33864   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33865   return jresult;
33866 }
33867
33868
33869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33870   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33871   float arg2 ;
33872
33873   arg1 = (Dali::Stage *)jarg1;
33874   arg2 = (float)jarg2;
33875   {
33876     try {
33877       (arg1)->KeepRendering(arg2);
33878     } catch (std::out_of_range& e) {
33879       {
33880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33881       };
33882     } catch (std::exception& e) {
33883       {
33884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33885       };
33886     } catch (...) {
33887       {
33888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33889       };
33890     }
33891   }
33892 }
33893
33894
33895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33896   void * jresult ;
33897   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33898   Dali::Stage::KeyEventSignalType *result = 0 ;
33899
33900   arg1 = (Dali::Stage *)jarg1;
33901   {
33902     try {
33903       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33904     } catch (std::out_of_range& e) {
33905       {
33906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33907       };
33908     } catch (std::exception& e) {
33909       {
33910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33911       };
33912     } catch (...) {
33913       {
33914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33915       };
33916     }
33917   }
33918   jresult = (void *)result;
33919   return jresult;
33920 }
33921
33922
33923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33924   void * jresult ;
33925   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33926   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33927
33928   arg1 = (Dali::Stage *)jarg1;
33929   {
33930     try {
33931       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33932     } catch (std::out_of_range& e) {
33933       {
33934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33935       };
33936     } catch (std::exception& e) {
33937       {
33938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33939       };
33940     } catch (...) {
33941       {
33942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33943       };
33944     }
33945   }
33946   jresult = (void *)result;
33947   return jresult;
33948 }
33949
33950
33951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33952   void * jresult ;
33953   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33954   Dali::Stage::TouchSignalType *result = 0 ;
33955
33956   arg1 = (Dali::Stage *)jarg1;
33957   {
33958     try {
33959       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33967       };
33968     } catch (...) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33971       };
33972     }
33973   }
33974   jresult = (void *)result;
33975   return jresult;
33976 }
33977
33978
33979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33980   void * jresult ;
33981   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33982   Dali::Stage::WheelEventSignalType *result = 0 ;
33983
33984   arg1 = (Dali::Stage *)jarg1;
33985   {
33986     try {
33987       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33988     } catch (std::out_of_range& e) {
33989       {
33990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (std::exception& e) {
33993       {
33994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33995       };
33996     } catch (...) {
33997       {
33998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33999       };
34000     }
34001   }
34002   jresult = (void *)result;
34003   return jresult;
34004 }
34005
34006
34007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34008   void * jresult ;
34009   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34010   Dali::Stage::ContextStatusSignal *result = 0 ;
34011
34012   arg1 = (Dali::Stage *)jarg1;
34013   {
34014     try {
34015       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34016     } catch (std::out_of_range& e) {
34017       {
34018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34019       };
34020     } catch (std::exception& e) {
34021       {
34022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34023       };
34024     } catch (...) {
34025       {
34026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34027       };
34028     }
34029   }
34030   jresult = (void *)result;
34031   return jresult;
34032 }
34033
34034
34035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34036   void * jresult ;
34037   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34038   Dali::Stage::ContextStatusSignal *result = 0 ;
34039
34040   arg1 = (Dali::Stage *)jarg1;
34041   {
34042     try {
34043       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34044     } catch (std::out_of_range& e) {
34045       {
34046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34047       };
34048     } catch (std::exception& e) {
34049       {
34050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34051       };
34052     } catch (...) {
34053       {
34054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34055       };
34056     }
34057   }
34058   jresult = (void *)result;
34059   return jresult;
34060 }
34061
34062
34063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34064   void * jresult ;
34065   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34066   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34067
34068   arg1 = (Dali::Stage *)jarg1;
34069   {
34070     try {
34071       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34072     } catch (std::out_of_range& e) {
34073       {
34074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34075       };
34076     } catch (std::exception& e) {
34077       {
34078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34079       };
34080     } catch (...) {
34081       {
34082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34083       };
34084     }
34085   }
34086   jresult = (void *)result;
34087   return jresult;
34088 }
34089
34090
34091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34092   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34093
34094   arg1 = (Dali::RelayoutContainer *)jarg1;
34095   {
34096     try {
34097       delete arg1;
34098     } catch (std::out_of_range& e) {
34099       {
34100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34101       };
34102     } catch (std::exception& e) {
34103       {
34104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34105       };
34106     } catch (...) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34109       };
34110     }
34111   }
34112 }
34113
34114
34115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34116   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34117   Dali::Actor *arg2 = 0 ;
34118   Dali::Vector2 *arg3 = 0 ;
34119
34120   arg1 = (Dali::RelayoutContainer *)jarg1;
34121   arg2 = (Dali::Actor *)jarg2;
34122   if (!arg2) {
34123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34124     return ;
34125   }
34126   arg3 = (Dali::Vector2 *)jarg3;
34127   if (!arg3) {
34128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34129     return ;
34130   }
34131   {
34132     try {
34133       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34134     } catch (std::out_of_range& e) {
34135       {
34136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34137       };
34138     } catch (std::exception& e) {
34139       {
34140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34141       };
34142     } catch (...) {
34143       {
34144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34145       };
34146     }
34147   }
34148 }
34149
34150
34151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34152   void * jresult ;
34153   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34154   Dali::CustomActor result;
34155
34156   arg1 = (Dali::CustomActorImpl *)jarg1;
34157   {
34158     try {
34159       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34160     } catch (std::out_of_range& e) {
34161       {
34162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34163       };
34164     } catch (std::exception& e) {
34165       {
34166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34167       };
34168     } catch (...) {
34169       {
34170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34171       };
34172     }
34173   }
34174   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34175   return jresult;
34176 }
34177
34178
34179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34180   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34181   int arg2 ;
34182
34183   arg1 = (Dali::CustomActorImpl *)jarg1;
34184   arg2 = (int)jarg2;
34185   {
34186     try {
34187       (arg1)->OnStageConnection(arg2);
34188     } catch (std::out_of_range& e) {
34189       {
34190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34191       };
34192     } catch (std::exception& e) {
34193       {
34194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34195       };
34196     } catch (...) {
34197       {
34198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34199       };
34200     }
34201   }
34202 }
34203
34204
34205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34206   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34207
34208   arg1 = (Dali::CustomActorImpl *)jarg1;
34209   {
34210     try {
34211       (arg1)->OnStageDisconnection();
34212     } catch (std::out_of_range& e) {
34213       {
34214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34215       };
34216     } catch (std::exception& e) {
34217       {
34218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34219       };
34220     } catch (...) {
34221       {
34222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34223       };
34224     }
34225   }
34226 }
34227
34228
34229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34230   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34231   Dali::Actor *arg2 = 0 ;
34232
34233   arg1 = (Dali::CustomActorImpl *)jarg1;
34234   arg2 = (Dali::Actor *)jarg2;
34235   if (!arg2) {
34236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34237     return ;
34238   }
34239   {
34240     try {
34241       (arg1)->OnChildAdd(*arg2);
34242     } catch (std::out_of_range& e) {
34243       {
34244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34245       };
34246     } catch (std::exception& e) {
34247       {
34248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34249       };
34250     } catch (...) {
34251       {
34252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34253       };
34254     }
34255   }
34256 }
34257
34258
34259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34260   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34261   Dali::Actor *arg2 = 0 ;
34262
34263   arg1 = (Dali::CustomActorImpl *)jarg1;
34264   arg2 = (Dali::Actor *)jarg2;
34265   if (!arg2) {
34266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34267     return ;
34268   }
34269   {
34270     try {
34271       (arg1)->OnChildRemove(*arg2);
34272     } catch (std::out_of_range& e) {
34273       {
34274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34275       };
34276     } catch (std::exception& e) {
34277       {
34278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34283       };
34284     }
34285   }
34286 }
34287
34288
34289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34290   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34291   Dali::Property::Index arg2 ;
34292   Dali::Property::Value arg3 ;
34293   Dali::Property::Value *argp3 ;
34294
34295   arg1 = (Dali::CustomActorImpl *)jarg1;
34296   arg2 = (Dali::Property::Index)jarg2;
34297   argp3 = (Dali::Property::Value *)jarg3;
34298   if (!argp3) {
34299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34300     return ;
34301   }
34302   arg3 = *argp3;
34303   {
34304     try {
34305       (arg1)->OnPropertySet(arg2,arg3);
34306     } catch (std::out_of_range& e) {
34307       {
34308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34309       };
34310     } catch (std::exception& e) {
34311       {
34312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34313       };
34314     } catch (...) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34317       };
34318     }
34319   }
34320 }
34321
34322
34323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34324   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34325   Dali::Vector3 *arg2 = 0 ;
34326
34327   arg1 = (Dali::CustomActorImpl *)jarg1;
34328   arg2 = (Dali::Vector3 *)jarg2;
34329   if (!arg2) {
34330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34331     return ;
34332   }
34333   {
34334     try {
34335       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34336     } catch (std::out_of_range& e) {
34337       {
34338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34339       };
34340     } catch (std::exception& e) {
34341       {
34342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34343       };
34344     } catch (...) {
34345       {
34346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34347       };
34348     }
34349   }
34350 }
34351
34352
34353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34354   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34355   Dali::Animation *arg2 = 0 ;
34356   Dali::Vector3 *arg3 = 0 ;
34357
34358   arg1 = (Dali::CustomActorImpl *)jarg1;
34359   arg2 = (Dali::Animation *)jarg2;
34360   if (!arg2) {
34361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34362     return ;
34363   }
34364   arg3 = (Dali::Vector3 *)jarg3;
34365   if (!arg3) {
34366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34367     return ;
34368   }
34369   {
34370     try {
34371       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (...) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34383       };
34384     }
34385   }
34386 }
34387
34388
34389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34390   unsigned int jresult ;
34391   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34392   Dali::TouchEvent *arg2 = 0 ;
34393   bool result;
34394
34395   arg1 = (Dali::CustomActorImpl *)jarg1;
34396   arg2 = (Dali::TouchEvent *)jarg2;
34397   if (!arg2) {
34398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34399     return 0;
34400   }
34401   {
34402     try {
34403       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34404     } catch (std::out_of_range& e) {
34405       {
34406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34407       };
34408     } catch (std::exception& e) {
34409       {
34410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34411       };
34412     } catch (...) {
34413       {
34414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34415       };
34416     }
34417   }
34418   jresult = result;
34419   return jresult;
34420 }
34421
34422
34423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34424   unsigned int jresult ;
34425   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34426   Dali::HoverEvent *arg2 = 0 ;
34427   bool result;
34428
34429   arg1 = (Dali::CustomActorImpl *)jarg1;
34430   arg2 = (Dali::HoverEvent *)jarg2;
34431   if (!arg2) {
34432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34433     return 0;
34434   }
34435   {
34436     try {
34437       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34438     } catch (std::out_of_range& e) {
34439       {
34440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34441       };
34442     } catch (std::exception& e) {
34443       {
34444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34445       };
34446     } catch (...) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34449       };
34450     }
34451   }
34452   jresult = result;
34453   return jresult;
34454 }
34455
34456
34457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34458   unsigned int jresult ;
34459   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34460   Dali::KeyEvent *arg2 = 0 ;
34461   bool result;
34462
34463   arg1 = (Dali::CustomActorImpl *)jarg1;
34464   arg2 = (Dali::KeyEvent *)jarg2;
34465   if (!arg2) {
34466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34467     return 0;
34468   }
34469   {
34470     try {
34471       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34479       };
34480     } catch (...) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34483       };
34484     }
34485   }
34486   jresult = result;
34487   return jresult;
34488 }
34489
34490
34491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34492   unsigned int jresult ;
34493   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34494   Dali::WheelEvent *arg2 = 0 ;
34495   bool result;
34496
34497   arg1 = (Dali::CustomActorImpl *)jarg1;
34498   arg2 = (Dali::WheelEvent *)jarg2;
34499   if (!arg2) {
34500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34501     return 0;
34502   }
34503   {
34504     try {
34505       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34506     } catch (std::out_of_range& e) {
34507       {
34508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34509       };
34510     } catch (std::exception& e) {
34511       {
34512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34513       };
34514     } catch (...) {
34515       {
34516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34517       };
34518     }
34519   }
34520   jresult = result;
34521   return jresult;
34522 }
34523
34524
34525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34526   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34527   Dali::Vector2 *arg2 = 0 ;
34528   Dali::RelayoutContainer *arg3 = 0 ;
34529
34530   arg1 = (Dali::CustomActorImpl *)jarg1;
34531   arg2 = (Dali::Vector2 *)jarg2;
34532   if (!arg2) {
34533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34534     return ;
34535   }
34536   arg3 = (Dali::RelayoutContainer *)jarg3;
34537   if (!arg3) {
34538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34539     return ;
34540   }
34541   {
34542     try {
34543       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34544     } catch (std::out_of_range& e) {
34545       {
34546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (std::exception& e) {
34549       {
34550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558 }
34559
34560
34561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34562   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34563   Dali::ResizePolicy::Type arg2 ;
34564   Dali::Dimension::Type arg3 ;
34565
34566   arg1 = (Dali::CustomActorImpl *)jarg1;
34567   arg2 = (Dali::ResizePolicy::Type)jarg2;
34568   arg3 = (Dali::Dimension::Type)jarg3;
34569   {
34570     try {
34571       (arg1)->OnSetResizePolicy(arg2,arg3);
34572     } catch (std::out_of_range& e) {
34573       {
34574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34575       };
34576     } catch (std::exception& e) {
34577       {
34578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34579       };
34580     } catch (...) {
34581       {
34582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34583       };
34584     }
34585   }
34586 }
34587
34588
34589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34590   void * jresult ;
34591   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34592   Dali::Vector3 result;
34593
34594   arg1 = (Dali::CustomActorImpl *)jarg1;
34595   {
34596     try {
34597       result = (arg1)->GetNaturalSize();
34598     } catch (std::out_of_range& e) {
34599       {
34600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34601       };
34602     } catch (std::exception& e) {
34603       {
34604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34605       };
34606     } catch (...) {
34607       {
34608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34609       };
34610     }
34611   }
34612   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34613   return jresult;
34614 }
34615
34616
34617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34618   float jresult ;
34619   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34620   Dali::Actor *arg2 = 0 ;
34621   Dali::Dimension::Type arg3 ;
34622   float result;
34623
34624   arg1 = (Dali::CustomActorImpl *)jarg1;
34625   arg2 = (Dali::Actor *)jarg2;
34626   if (!arg2) {
34627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34628     return 0;
34629   }
34630   arg3 = (Dali::Dimension::Type)jarg3;
34631   {
34632     try {
34633       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34634     } catch (std::out_of_range& e) {
34635       {
34636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34637       };
34638     } catch (std::exception& e) {
34639       {
34640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34641       };
34642     } catch (...) {
34643       {
34644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34645       };
34646     }
34647   }
34648   jresult = result;
34649   return jresult;
34650 }
34651
34652
34653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34654   float jresult ;
34655   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34656   float arg2 ;
34657   float result;
34658
34659   arg1 = (Dali::CustomActorImpl *)jarg1;
34660   arg2 = (float)jarg2;
34661   {
34662     try {
34663       result = (float)(arg1)->GetHeightForWidth(arg2);
34664     } catch (std::out_of_range& e) {
34665       {
34666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34667       };
34668     } catch (std::exception& e) {
34669       {
34670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34671       };
34672     } catch (...) {
34673       {
34674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34675       };
34676     }
34677   }
34678   jresult = result;
34679   return jresult;
34680 }
34681
34682
34683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34684   float jresult ;
34685   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34686   float arg2 ;
34687   float result;
34688
34689   arg1 = (Dali::CustomActorImpl *)jarg1;
34690   arg2 = (float)jarg2;
34691   {
34692     try {
34693       result = (float)(arg1)->GetWidthForHeight(arg2);
34694     } catch (std::out_of_range& e) {
34695       {
34696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34697       };
34698     } catch (std::exception& e) {
34699       {
34700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34701       };
34702     } catch (...) {
34703       {
34704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34705       };
34706     }
34707   }
34708   jresult = result;
34709   return jresult;
34710 }
34711
34712
34713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34714   unsigned int jresult ;
34715   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34716   Dali::Dimension::Type arg2 ;
34717   bool result;
34718
34719   arg1 = (Dali::CustomActorImpl *)jarg1;
34720   arg2 = (Dali::Dimension::Type)jarg2;
34721   {
34722     try {
34723       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34724     } catch (std::out_of_range& e) {
34725       {
34726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34727       };
34728     } catch (std::exception& e) {
34729       {
34730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34731       };
34732     } catch (...) {
34733       {
34734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34735       };
34736     }
34737   }
34738   jresult = result;
34739   return jresult;
34740 }
34741
34742
34743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34744   unsigned int jresult ;
34745   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34746   bool result;
34747
34748   arg1 = (Dali::CustomActorImpl *)jarg1;
34749   {
34750     try {
34751       result = (bool)(arg1)->RelayoutDependentOnChildren();
34752     } catch (std::out_of_range& e) {
34753       {
34754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34755       };
34756     } catch (std::exception& e) {
34757       {
34758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34759       };
34760     } catch (...) {
34761       {
34762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34763       };
34764     }
34765   }
34766   jresult = result;
34767   return jresult;
34768 }
34769
34770
34771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34772   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34773   Dali::Dimension::Type arg2 ;
34774
34775   arg1 = (Dali::CustomActorImpl *)jarg1;
34776   arg2 = (Dali::Dimension::Type)jarg2;
34777   {
34778     try {
34779       (arg1)->OnCalculateRelayoutSize(arg2);
34780     } catch (std::out_of_range& e) {
34781       {
34782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34783       };
34784     } catch (std::exception& e) {
34785       {
34786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34787       };
34788     } catch (...) {
34789       {
34790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34791       };
34792     }
34793   }
34794 }
34795
34796
34797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34798   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34799   float arg2 ;
34800   Dali::Dimension::Type arg3 ;
34801
34802   arg1 = (Dali::CustomActorImpl *)jarg1;
34803   arg2 = (float)jarg2;
34804   arg3 = (Dali::Dimension::Type)jarg3;
34805   {
34806     try {
34807       (arg1)->OnLayoutNegotiated(arg2,arg3);
34808     } catch (std::out_of_range& e) {
34809       {
34810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34811       };
34812     } catch (std::exception& e) {
34813       {
34814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34815       };
34816     } catch (...) {
34817       {
34818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34819       };
34820     }
34821   }
34822 }
34823
34824
34825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34826   unsigned int jresult ;
34827   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34828   bool result;
34829
34830   arg1 = (Dali::CustomActorImpl *)jarg1;
34831   {
34832     try {
34833       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34841       };
34842     } catch (...) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34845       };
34846     }
34847   }
34848   jresult = result;
34849   return jresult;
34850 }
34851
34852
34853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34854   unsigned int jresult ;
34855   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34856   bool result;
34857
34858   arg1 = (Dali::CustomActorImpl *)jarg1;
34859   {
34860     try {
34861       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34862     } catch (std::out_of_range& e) {
34863       {
34864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34865       };
34866     } catch (std::exception& e) {
34867       {
34868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34869       };
34870     } catch (...) {
34871       {
34872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34873       };
34874     }
34875   }
34876   jresult = result;
34877   return jresult;
34878 }
34879
34880
34881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34882   unsigned int jresult ;
34883   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34884   bool result;
34885
34886   arg1 = (Dali::CustomActorImpl *)jarg1;
34887   {
34888     try {
34889       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34890     } catch (std::out_of_range& e) {
34891       {
34892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34893       };
34894     } catch (std::exception& e) {
34895       {
34896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34897       };
34898     } catch (...) {
34899       {
34900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34901       };
34902     }
34903   }
34904   jresult = result;
34905   return jresult;
34906 }
34907
34908
34909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34910   unsigned int jresult ;
34911   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34912   bool result;
34913
34914   arg1 = (Dali::CustomActorImpl *)jarg1;
34915   {
34916     try {
34917       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34918     } catch (std::out_of_range& e) {
34919       {
34920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34921       };
34922     } catch (std::exception& e) {
34923       {
34924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34925       };
34926     } catch (...) {
34927       {
34928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34929       };
34930     }
34931   }
34932   jresult = result;
34933   return jresult;
34934 }
34935
34936
34937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34938   void * jresult ;
34939   Dali::CustomActor *result = 0 ;
34940
34941   {
34942     try {
34943       result = (Dali::CustomActor *)new Dali::CustomActor();
34944     } catch (std::out_of_range& e) {
34945       {
34946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34947       };
34948     } catch (std::exception& e) {
34949       {
34950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34951       };
34952     } catch (...) {
34953       {
34954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34955       };
34956     }
34957   }
34958   jresult = (void *)result;
34959   return jresult;
34960 }
34961
34962
34963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34964   void * jresult ;
34965   Dali::BaseHandle arg1 ;
34966   Dali::BaseHandle *argp1 ;
34967   Dali::CustomActor result;
34968
34969   argp1 = (Dali::BaseHandle *)jarg1;
34970   if (!argp1) {
34971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34972     return 0;
34973   }
34974   arg1 = *argp1;
34975   {
34976     try {
34977       result = Dali::CustomActor::DownCast(arg1);
34978     } catch (std::out_of_range& e) {
34979       {
34980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34981       };
34982     } catch (std::exception& e) {
34983       {
34984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34985       };
34986     } catch (...) {
34987       {
34988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34989       };
34990     }
34991   }
34992   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34993   return jresult;
34994 }
34995
34996
34997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34998   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34999
35000   arg1 = (Dali::CustomActor *)jarg1;
35001   {
35002     try {
35003       delete arg1;
35004     } catch (std::out_of_range& e) {
35005       {
35006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35007       };
35008     } catch (std::exception& e) {
35009       {
35010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35011       };
35012     } catch (...) {
35013       {
35014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35015       };
35016     }
35017   }
35018 }
35019
35020
35021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35022   void * jresult ;
35023   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35024   Dali::CustomActorImpl *result = 0 ;
35025
35026   arg1 = (Dali::CustomActor *)jarg1;
35027   {
35028     try {
35029       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35030     } catch (std::out_of_range& e) {
35031       {
35032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35033       };
35034     } catch (std::exception& e) {
35035       {
35036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35037       };
35038     } catch (...) {
35039       {
35040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35041       };
35042     }
35043   }
35044   jresult = (void *)result;
35045   return jresult;
35046 }
35047
35048
35049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35050   void * jresult ;
35051   Dali::CustomActorImpl *arg1 = 0 ;
35052   Dali::CustomActor *result = 0 ;
35053
35054   arg1 = (Dali::CustomActorImpl *)jarg1;
35055   if (!arg1) {
35056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35057     return 0;
35058   }
35059   {
35060     try {
35061       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35062     } catch (std::out_of_range& e) {
35063       {
35064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35065       };
35066     } catch (std::exception& e) {
35067       {
35068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35069       };
35070     } catch (...) {
35071       {
35072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35073       };
35074     }
35075   }
35076   jresult = (void *)result;
35077   return jresult;
35078 }
35079
35080
35081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35082   void * jresult ;
35083   Dali::CustomActor *arg1 = 0 ;
35084   Dali::CustomActor *result = 0 ;
35085
35086   arg1 = (Dali::CustomActor *)jarg1;
35087   if (!arg1) {
35088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35089     return 0;
35090   }
35091   {
35092     try {
35093       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35094     } catch (std::out_of_range& e) {
35095       {
35096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35097       };
35098     } catch (std::exception& e) {
35099       {
35100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35101       };
35102     } catch (...) {
35103       {
35104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35105       };
35106     }
35107   }
35108   jresult = (void *)result;
35109   return jresult;
35110 }
35111
35112
35113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35114   void * jresult ;
35115   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35116   Dali::CustomActor *arg2 = 0 ;
35117   Dali::CustomActor *result = 0 ;
35118
35119   arg1 = (Dali::CustomActor *)jarg1;
35120   arg2 = (Dali::CustomActor *)jarg2;
35121   if (!arg2) {
35122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35123     return 0;
35124   }
35125   {
35126     try {
35127       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35128     } catch (std::out_of_range& e) {
35129       {
35130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35131       };
35132     } catch (std::exception& e) {
35133       {
35134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35135       };
35136     } catch (...) {
35137       {
35138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35139       };
35140     }
35141   }
35142   jresult = (void *)result;
35143   return jresult;
35144 }
35145
35146
35147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35148   int jresult ;
35149   int result;
35150
35151   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35152   jresult = (int)result;
35153   return jresult;
35154 }
35155
35156
35157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35158   int jresult ;
35159   int result;
35160
35161   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35162   jresult = (int)result;
35163   return jresult;
35164 }
35165
35166
35167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35168   int jresult ;
35169   int result;
35170
35171   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35172   jresult = (int)result;
35173   return jresult;
35174 }
35175
35176
35177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35178   int jresult ;
35179   int result;
35180
35181   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35182   jresult = (int)result;
35183   return jresult;
35184 }
35185
35186
35187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35188   int jresult ;
35189   int result;
35190
35191   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35192   jresult = (int)result;
35193   return jresult;
35194 }
35195
35196
35197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35198   int jresult ;
35199   int result;
35200
35201   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35202   jresult = (int)result;
35203   return jresult;
35204 }
35205
35206
35207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35208   int jresult ;
35209   int result;
35210
35211   result = (int)Dali::PanGestureDetector::Property::PANNING;
35212   jresult = (int)result;
35213   return jresult;
35214 }
35215
35216
35217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35218   void * jresult ;
35219   Dali::PanGestureDetector::Property *result = 0 ;
35220
35221   {
35222     try {
35223       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35224     } catch (std::out_of_range& e) {
35225       {
35226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35227       };
35228     } catch (std::exception& e) {
35229       {
35230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35231       };
35232     } catch (...) {
35233       {
35234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35235       };
35236     }
35237   }
35238   jresult = (void *)result;
35239   return jresult;
35240 }
35241
35242
35243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35244   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35245
35246   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35247   {
35248     try {
35249       delete arg1;
35250     } catch (std::out_of_range& e) {
35251       {
35252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35253       };
35254     } catch (std::exception& e) {
35255       {
35256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35257       };
35258     } catch (...) {
35259       {
35260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35261       };
35262     }
35263   }
35264 }
35265
35266
35267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35268   void * jresult ;
35269   Dali::Radian *result = 0 ;
35270
35271   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35272   jresult = (void *)result;
35273   return jresult;
35274 }
35275
35276
35277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35278   void * jresult ;
35279   Dali::Radian *result = 0 ;
35280
35281   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35282   jresult = (void *)result;
35283   return jresult;
35284 }
35285
35286
35287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35288   void * jresult ;
35289   Dali::Radian *result = 0 ;
35290
35291   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35292   jresult = (void *)result;
35293   return jresult;
35294 }
35295
35296
35297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35298   void * jresult ;
35299   Dali::Radian *result = 0 ;
35300
35301   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35302   jresult = (void *)result;
35303   return jresult;
35304 }
35305
35306
35307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35308   void * jresult ;
35309   Dali::Radian *result = 0 ;
35310
35311   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35312   jresult = (void *)result;
35313   return jresult;
35314 }
35315
35316
35317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35318   void * jresult ;
35319   Dali::Radian *result = 0 ;
35320
35321   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35322   jresult = (void *)result;
35323   return jresult;
35324 }
35325
35326
35327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35328   void * jresult ;
35329   Dali::Radian *result = 0 ;
35330
35331   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35332   jresult = (void *)result;
35333   return jresult;
35334 }
35335
35336
35337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35338   void * jresult ;
35339   Dali::PanGestureDetector *result = 0 ;
35340
35341   {
35342     try {
35343       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35344     } catch (std::out_of_range& e) {
35345       {
35346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35347       };
35348     } catch (std::exception& e) {
35349       {
35350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35351       };
35352     } catch (...) {
35353       {
35354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35355       };
35356     }
35357   }
35358   jresult = (void *)result;
35359   return jresult;
35360 }
35361
35362
35363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35364   void * jresult ;
35365   Dali::PanGestureDetector result;
35366
35367   {
35368     try {
35369       result = Dali::PanGestureDetector::New();
35370     } catch (std::out_of_range& e) {
35371       {
35372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35373       };
35374     } catch (std::exception& e) {
35375       {
35376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35377       };
35378     } catch (...) {
35379       {
35380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35381       };
35382     }
35383   }
35384   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35385   return jresult;
35386 }
35387
35388
35389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35390   void * jresult ;
35391   Dali::BaseHandle arg1 ;
35392   Dali::BaseHandle *argp1 ;
35393   Dali::PanGestureDetector result;
35394
35395   argp1 = (Dali::BaseHandle *)jarg1;
35396   if (!argp1) {
35397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35398     return 0;
35399   }
35400   arg1 = *argp1;
35401   {
35402     try {
35403       result = Dali::PanGestureDetector::DownCast(arg1);
35404     } catch (std::out_of_range& e) {
35405       {
35406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35407       };
35408     } catch (std::exception& e) {
35409       {
35410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35411       };
35412     } catch (...) {
35413       {
35414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35415       };
35416     }
35417   }
35418   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35419   return jresult;
35420 }
35421
35422
35423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35424   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35425
35426   arg1 = (Dali::PanGestureDetector *)jarg1;
35427   {
35428     try {
35429       delete arg1;
35430     } catch (std::out_of_range& e) {
35431       {
35432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35433       };
35434     } catch (std::exception& e) {
35435       {
35436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35437       };
35438     } catch (...) {
35439       {
35440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35441       };
35442     }
35443   }
35444 }
35445
35446
35447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35448   void * jresult ;
35449   Dali::PanGestureDetector *arg1 = 0 ;
35450   Dali::PanGestureDetector *result = 0 ;
35451
35452   arg1 = (Dali::PanGestureDetector *)jarg1;
35453   if (!arg1) {
35454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35455     return 0;
35456   }
35457   {
35458     try {
35459       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35460     } catch (std::out_of_range& e) {
35461       {
35462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35463       };
35464     } catch (std::exception& e) {
35465       {
35466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35467       };
35468     } catch (...) {
35469       {
35470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35471       };
35472     }
35473   }
35474   jresult = (void *)result;
35475   return jresult;
35476 }
35477
35478
35479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35480   void * jresult ;
35481   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35482   Dali::PanGestureDetector *arg2 = 0 ;
35483   Dali::PanGestureDetector *result = 0 ;
35484
35485   arg1 = (Dali::PanGestureDetector *)jarg1;
35486   arg2 = (Dali::PanGestureDetector *)jarg2;
35487   if (!arg2) {
35488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35489     return 0;
35490   }
35491   {
35492     try {
35493       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35494     } catch (std::out_of_range& e) {
35495       {
35496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35497       };
35498     } catch (std::exception& e) {
35499       {
35500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35501       };
35502     } catch (...) {
35503       {
35504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35505       };
35506     }
35507   }
35508   jresult = (void *)result;
35509   return jresult;
35510 }
35511
35512
35513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35514   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35515   unsigned int arg2 ;
35516
35517   arg1 = (Dali::PanGestureDetector *)jarg1;
35518   arg2 = (unsigned int)jarg2;
35519   {
35520     try {
35521       (arg1)->SetMinimumTouchesRequired(arg2);
35522     } catch (std::out_of_range& e) {
35523       {
35524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35525       };
35526     } catch (std::exception& e) {
35527       {
35528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35529       };
35530     } catch (...) {
35531       {
35532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35533       };
35534     }
35535   }
35536 }
35537
35538
35539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35540   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35541   unsigned int arg2 ;
35542
35543   arg1 = (Dali::PanGestureDetector *)jarg1;
35544   arg2 = (unsigned int)jarg2;
35545   {
35546     try {
35547       (arg1)->SetMaximumTouchesRequired(arg2);
35548     } catch (std::out_of_range& e) {
35549       {
35550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35551       };
35552     } catch (std::exception& e) {
35553       {
35554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35555       };
35556     } catch (...) {
35557       {
35558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35559       };
35560     }
35561   }
35562 }
35563
35564
35565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35566   unsigned int jresult ;
35567   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35568   unsigned int result;
35569
35570   arg1 = (Dali::PanGestureDetector *)jarg1;
35571   {
35572     try {
35573       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35574     } catch (std::out_of_range& e) {
35575       {
35576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35577       };
35578     } catch (std::exception& e) {
35579       {
35580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35581       };
35582     } catch (...) {
35583       {
35584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35585       };
35586     }
35587   }
35588   jresult = result;
35589   return jresult;
35590 }
35591
35592
35593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35594   unsigned int jresult ;
35595   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35596   unsigned int result;
35597
35598   arg1 = (Dali::PanGestureDetector *)jarg1;
35599   {
35600     try {
35601       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35602     } catch (std::out_of_range& e) {
35603       {
35604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35605       };
35606     } catch (std::exception& e) {
35607       {
35608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35609       };
35610     } catch (...) {
35611       {
35612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35613       };
35614     }
35615   }
35616   jresult = result;
35617   return jresult;
35618 }
35619
35620
35621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35622   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35623   Dali::Radian arg2 ;
35624   Dali::Radian arg3 ;
35625   Dali::Radian *argp2 ;
35626   Dali::Radian *argp3 ;
35627
35628   arg1 = (Dali::PanGestureDetector *)jarg1;
35629   argp2 = (Dali::Radian *)jarg2;
35630   if (!argp2) {
35631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35632     return ;
35633   }
35634   arg2 = *argp2;
35635   argp3 = (Dali::Radian *)jarg3;
35636   if (!argp3) {
35637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35638     return ;
35639   }
35640   arg3 = *argp3;
35641   {
35642     try {
35643       (arg1)->AddAngle(arg2,arg3);
35644     } catch (std::out_of_range& e) {
35645       {
35646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35647       };
35648     } catch (std::exception& e) {
35649       {
35650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35651       };
35652     } catch (...) {
35653       {
35654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35655       };
35656     }
35657   }
35658 }
35659
35660
35661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35662   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35663   Dali::Radian arg2 ;
35664   Dali::Radian *argp2 ;
35665
35666   arg1 = (Dali::PanGestureDetector *)jarg1;
35667   argp2 = (Dali::Radian *)jarg2;
35668   if (!argp2) {
35669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35670     return ;
35671   }
35672   arg2 = *argp2;
35673   {
35674     try {
35675       (arg1)->AddAngle(arg2);
35676     } catch (std::out_of_range& e) {
35677       {
35678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35679       };
35680     } catch (std::exception& e) {
35681       {
35682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35683       };
35684     } catch (...) {
35685       {
35686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35687       };
35688     }
35689   }
35690 }
35691
35692
35693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35694   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35695   Dali::Radian arg2 ;
35696   Dali::Radian arg3 ;
35697   Dali::Radian *argp2 ;
35698   Dali::Radian *argp3 ;
35699
35700   arg1 = (Dali::PanGestureDetector *)jarg1;
35701   argp2 = (Dali::Radian *)jarg2;
35702   if (!argp2) {
35703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35704     return ;
35705   }
35706   arg2 = *argp2;
35707   argp3 = (Dali::Radian *)jarg3;
35708   if (!argp3) {
35709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35710     return ;
35711   }
35712   arg3 = *argp3;
35713   {
35714     try {
35715       (arg1)->AddDirection(arg2,arg3);
35716     } catch (std::out_of_range& e) {
35717       {
35718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35719       };
35720     } catch (std::exception& e) {
35721       {
35722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35723       };
35724     } catch (...) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35727       };
35728     }
35729   }
35730 }
35731
35732
35733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35734   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35735   Dali::Radian arg2 ;
35736   Dali::Radian *argp2 ;
35737
35738   arg1 = (Dali::PanGestureDetector *)jarg1;
35739   argp2 = (Dali::Radian *)jarg2;
35740   if (!argp2) {
35741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35742     return ;
35743   }
35744   arg2 = *argp2;
35745   {
35746     try {
35747       (arg1)->AddDirection(arg2);
35748     } catch (std::out_of_range& e) {
35749       {
35750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35751       };
35752     } catch (std::exception& e) {
35753       {
35754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35755       };
35756     } catch (...) {
35757       {
35758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35759       };
35760     }
35761   }
35762 }
35763
35764
35765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35766   unsigned long jresult ;
35767   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35768   size_t result;
35769
35770   arg1 = (Dali::PanGestureDetector *)jarg1;
35771   {
35772     try {
35773       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35774     } catch (std::out_of_range& e) {
35775       {
35776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35777       };
35778     } catch (std::exception& e) {
35779       {
35780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35781       };
35782     } catch (...) {
35783       {
35784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35785       };
35786     }
35787   }
35788   jresult = (unsigned long)result;
35789   return jresult;
35790 }
35791
35792
35793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35794   void * jresult ;
35795   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35796   size_t arg2 ;
35797   Dali::PanGestureDetector::AngleThresholdPair result;
35798
35799   arg1 = (Dali::PanGestureDetector *)jarg1;
35800   arg2 = (size_t)jarg2;
35801   {
35802     try {
35803       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35804     } catch (std::out_of_range& e) {
35805       {
35806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35807       };
35808     } catch (std::exception& e) {
35809       {
35810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35811       };
35812     } catch (...) {
35813       {
35814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35815       };
35816     }
35817   }
35818   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35819   return jresult;
35820 }
35821
35822
35823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35825
35826   arg1 = (Dali::PanGestureDetector *)jarg1;
35827   {
35828     try {
35829       (arg1)->ClearAngles();
35830     } catch (std::out_of_range& e) {
35831       {
35832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35833       };
35834     } catch (std::exception& e) {
35835       {
35836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35837       };
35838     } catch (...) {
35839       {
35840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35841       };
35842     }
35843   }
35844 }
35845
35846
35847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35848   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35849   Dali::Radian arg2 ;
35850   Dali::Radian *argp2 ;
35851
35852   arg1 = (Dali::PanGestureDetector *)jarg1;
35853   argp2 = (Dali::Radian *)jarg2;
35854   if (!argp2) {
35855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35856     return ;
35857   }
35858   arg2 = *argp2;
35859   {
35860     try {
35861       (arg1)->RemoveAngle(arg2);
35862     } catch (std::out_of_range& e) {
35863       {
35864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35865       };
35866     } catch (std::exception& e) {
35867       {
35868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35869       };
35870     } catch (...) {
35871       {
35872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35873       };
35874     }
35875   }
35876 }
35877
35878
35879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35880   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35881   Dali::Radian arg2 ;
35882   Dali::Radian *argp2 ;
35883
35884   arg1 = (Dali::PanGestureDetector *)jarg1;
35885   argp2 = (Dali::Radian *)jarg2;
35886   if (!argp2) {
35887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35888     return ;
35889   }
35890   arg2 = *argp2;
35891   {
35892     try {
35893       (arg1)->RemoveDirection(arg2);
35894     } catch (std::out_of_range& e) {
35895       {
35896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35897       };
35898     } catch (std::exception& e) {
35899       {
35900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35901       };
35902     } catch (...) {
35903       {
35904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35905       };
35906     }
35907   }
35908 }
35909
35910
35911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35912   void * jresult ;
35913   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35914   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35915
35916   arg1 = (Dali::PanGestureDetector *)jarg1;
35917   {
35918     try {
35919       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35920     } catch (std::out_of_range& e) {
35921       {
35922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35923       };
35924     } catch (std::exception& e) {
35925       {
35926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35927       };
35928     } catch (...) {
35929       {
35930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35931       };
35932     }
35933   }
35934   jresult = (void *)result;
35935   return jresult;
35936 }
35937
35938
35939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35940   Dali::PanGesture *arg1 = 0 ;
35941
35942   arg1 = (Dali::PanGesture *)jarg1;
35943   if (!arg1) {
35944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35945     return ;
35946   }
35947   {
35948     try {
35949       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35950     } catch (std::out_of_range& e) {
35951       {
35952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35953       };
35954     } catch (std::exception& e) {
35955       {
35956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35957       };
35958     } catch (...) {
35959       {
35960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35961       };
35962     }
35963   }
35964 }
35965
35966
35967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35968   void * jresult ;
35969   Dali::PanGesture *result = 0 ;
35970
35971   {
35972     try {
35973       result = (Dali::PanGesture *)new Dali::PanGesture();
35974     } catch (std::out_of_range& e) {
35975       {
35976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35977       };
35978     } catch (std::exception& e) {
35979       {
35980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35981       };
35982     } catch (...) {
35983       {
35984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35985       };
35986     }
35987   }
35988   jresult = (void *)result;
35989   return jresult;
35990 }
35991
35992
35993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35994   void * jresult ;
35995   Dali::Gesture::State arg1 ;
35996   Dali::PanGesture *result = 0 ;
35997
35998   arg1 = (Dali::Gesture::State)jarg1;
35999   {
36000     try {
36001       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36002     } catch (std::out_of_range& e) {
36003       {
36004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36005       };
36006     } catch (std::exception& e) {
36007       {
36008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36009       };
36010     } catch (...) {
36011       {
36012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36013       };
36014     }
36015   }
36016   jresult = (void *)result;
36017   return jresult;
36018 }
36019
36020
36021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36022   void * jresult ;
36023   Dali::PanGesture *arg1 = 0 ;
36024   Dali::PanGesture *result = 0 ;
36025
36026   arg1 = (Dali::PanGesture *)jarg1;
36027   if (!arg1) {
36028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36029     return 0;
36030   }
36031   {
36032     try {
36033       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36034     } catch (std::out_of_range& e) {
36035       {
36036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36037       };
36038     } catch (std::exception& e) {
36039       {
36040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36041       };
36042     } catch (...) {
36043       {
36044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36045       };
36046     }
36047   }
36048   jresult = (void *)result;
36049   return jresult;
36050 }
36051
36052
36053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36054   void * jresult ;
36055   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36056   Dali::PanGesture *arg2 = 0 ;
36057   Dali::PanGesture *result = 0 ;
36058
36059   arg1 = (Dali::PanGesture *)jarg1;
36060   arg2 = (Dali::PanGesture *)jarg2;
36061   if (!arg2) {
36062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36063     return 0;
36064   }
36065   {
36066     try {
36067       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36068     } catch (std::out_of_range& e) {
36069       {
36070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36071       };
36072     } catch (std::exception& e) {
36073       {
36074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36075       };
36076     } catch (...) {
36077       {
36078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36079       };
36080     }
36081   }
36082   jresult = (void *)result;
36083   return jresult;
36084 }
36085
36086
36087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36088   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36089
36090   arg1 = (Dali::PanGesture *)jarg1;
36091   {
36092     try {
36093       delete arg1;
36094     } catch (std::out_of_range& e) {
36095       {
36096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36097       };
36098     } catch (std::exception& e) {
36099       {
36100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36101       };
36102     } catch (...) {
36103       {
36104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36105       };
36106     }
36107   }
36108 }
36109
36110
36111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36112   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36113   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36114
36115   arg1 = (Dali::PanGesture *)jarg1;
36116   arg2 = (Dali::Vector2 *)jarg2;
36117   if (arg1) (arg1)->velocity = *arg2;
36118 }
36119
36120
36121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36122   void * jresult ;
36123   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36124   Dali::Vector2 *result = 0 ;
36125
36126   arg1 = (Dali::PanGesture *)jarg1;
36127   result = (Dali::Vector2 *)& ((arg1)->velocity);
36128   jresult = (void *)result;
36129   return jresult;
36130 }
36131
36132
36133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36134   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36135   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36136
36137   arg1 = (Dali::PanGesture *)jarg1;
36138   arg2 = (Dali::Vector2 *)jarg2;
36139   if (arg1) (arg1)->displacement = *arg2;
36140 }
36141
36142
36143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36144   void * jresult ;
36145   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36146   Dali::Vector2 *result = 0 ;
36147
36148   arg1 = (Dali::PanGesture *)jarg1;
36149   result = (Dali::Vector2 *)& ((arg1)->displacement);
36150   jresult = (void *)result;
36151   return jresult;
36152 }
36153
36154
36155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36156   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36157   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36158
36159   arg1 = (Dali::PanGesture *)jarg1;
36160   arg2 = (Dali::Vector2 *)jarg2;
36161   if (arg1) (arg1)->position = *arg2;
36162 }
36163
36164
36165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36166   void * jresult ;
36167   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36168   Dali::Vector2 *result = 0 ;
36169
36170   arg1 = (Dali::PanGesture *)jarg1;
36171   result = (Dali::Vector2 *)& ((arg1)->position);
36172   jresult = (void *)result;
36173   return jresult;
36174 }
36175
36176
36177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36178   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36179   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36180
36181   arg1 = (Dali::PanGesture *)jarg1;
36182   arg2 = (Dali::Vector2 *)jarg2;
36183   if (arg1) (arg1)->screenVelocity = *arg2;
36184 }
36185
36186
36187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36188   void * jresult ;
36189   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36190   Dali::Vector2 *result = 0 ;
36191
36192   arg1 = (Dali::PanGesture *)jarg1;
36193   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36194   jresult = (void *)result;
36195   return jresult;
36196 }
36197
36198
36199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36200   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36201   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36202
36203   arg1 = (Dali::PanGesture *)jarg1;
36204   arg2 = (Dali::Vector2 *)jarg2;
36205   if (arg1) (arg1)->screenDisplacement = *arg2;
36206 }
36207
36208
36209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36210   void * jresult ;
36211   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36212   Dali::Vector2 *result = 0 ;
36213
36214   arg1 = (Dali::PanGesture *)jarg1;
36215   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36216   jresult = (void *)result;
36217   return jresult;
36218 }
36219
36220
36221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36222   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36223   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36224
36225   arg1 = (Dali::PanGesture *)jarg1;
36226   arg2 = (Dali::Vector2 *)jarg2;
36227   if (arg1) (arg1)->screenPosition = *arg2;
36228 }
36229
36230
36231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36232   void * jresult ;
36233   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36234   Dali::Vector2 *result = 0 ;
36235
36236   arg1 = (Dali::PanGesture *)jarg1;
36237   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36238   jresult = (void *)result;
36239   return jresult;
36240 }
36241
36242
36243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36244   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36245   unsigned int arg2 ;
36246
36247   arg1 = (Dali::PanGesture *)jarg1;
36248   arg2 = (unsigned int)jarg2;
36249   if (arg1) (arg1)->numberOfTouches = arg2;
36250 }
36251
36252
36253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36254   unsigned int jresult ;
36255   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36256   unsigned int result;
36257
36258   arg1 = (Dali::PanGesture *)jarg1;
36259   result = (unsigned int) ((arg1)->numberOfTouches);
36260   jresult = result;
36261   return jresult;
36262 }
36263
36264
36265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36266   float jresult ;
36267   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36268   float result;
36269
36270   arg1 = (Dali::PanGesture *)jarg1;
36271   {
36272     try {
36273       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36274     } catch (std::out_of_range& e) {
36275       {
36276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36277       };
36278     } catch (std::exception& e) {
36279       {
36280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36281       };
36282     } catch (...) {
36283       {
36284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36285       };
36286     }
36287   }
36288   jresult = result;
36289   return jresult;
36290 }
36291
36292
36293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36294   float jresult ;
36295   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36296   float result;
36297
36298   arg1 = (Dali::PanGesture *)jarg1;
36299   {
36300     try {
36301       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36302     } catch (std::out_of_range& e) {
36303       {
36304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36305       };
36306     } catch (std::exception& e) {
36307       {
36308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36309       };
36310     } catch (...) {
36311       {
36312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36313       };
36314     }
36315   }
36316   jresult = result;
36317   return jresult;
36318 }
36319
36320
36321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36322   float jresult ;
36323   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36324   float result;
36325
36326   arg1 = (Dali::PanGesture *)jarg1;
36327   {
36328     try {
36329       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36330     } catch (std::out_of_range& e) {
36331       {
36332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36333       };
36334     } catch (std::exception& e) {
36335       {
36336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36337       };
36338     } catch (...) {
36339       {
36340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36341       };
36342     }
36343   }
36344   jresult = result;
36345   return jresult;
36346 }
36347
36348
36349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36350   float jresult ;
36351   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36352   float result;
36353
36354   arg1 = (Dali::PanGesture *)jarg1;
36355   {
36356     try {
36357       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36358     } catch (std::out_of_range& e) {
36359       {
36360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (std::exception& e) {
36363       {
36364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372   jresult = result;
36373   return jresult;
36374 }
36375
36376
36377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36378   void * jresult ;
36379   Dali::PinchGestureDetector *result = 0 ;
36380
36381   {
36382     try {
36383       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36384     } catch (std::out_of_range& e) {
36385       {
36386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36387       };
36388     } catch (std::exception& e) {
36389       {
36390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (...) {
36393       {
36394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36395       };
36396     }
36397   }
36398   jresult = (void *)result;
36399   return jresult;
36400 }
36401
36402
36403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36404   void * jresult ;
36405   Dali::PinchGestureDetector result;
36406
36407   {
36408     try {
36409       result = Dali::PinchGestureDetector::New();
36410     } catch (std::out_of_range& e) {
36411       {
36412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36413       };
36414     } catch (std::exception& e) {
36415       {
36416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36417       };
36418     } catch (...) {
36419       {
36420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36421       };
36422     }
36423   }
36424   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36425   return jresult;
36426 }
36427
36428
36429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36430   void * jresult ;
36431   Dali::BaseHandle arg1 ;
36432   Dali::BaseHandle *argp1 ;
36433   Dali::PinchGestureDetector result;
36434
36435   argp1 = (Dali::BaseHandle *)jarg1;
36436   if (!argp1) {
36437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36438     return 0;
36439   }
36440   arg1 = *argp1;
36441   {
36442     try {
36443       result = Dali::PinchGestureDetector::DownCast(arg1);
36444     } catch (std::out_of_range& e) {
36445       {
36446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36447       };
36448     } catch (std::exception& e) {
36449       {
36450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36451       };
36452     } catch (...) {
36453       {
36454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36455       };
36456     }
36457   }
36458   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36459   return jresult;
36460 }
36461
36462
36463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36464   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36465
36466   arg1 = (Dali::PinchGestureDetector *)jarg1;
36467   {
36468     try {
36469       delete arg1;
36470     } catch (std::out_of_range& e) {
36471       {
36472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36473       };
36474     } catch (std::exception& e) {
36475       {
36476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36477       };
36478     } catch (...) {
36479       {
36480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36481       };
36482     }
36483   }
36484 }
36485
36486
36487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36488   void * jresult ;
36489   Dali::PinchGestureDetector *arg1 = 0 ;
36490   Dali::PinchGestureDetector *result = 0 ;
36491
36492   arg1 = (Dali::PinchGestureDetector *)jarg1;
36493   if (!arg1) {
36494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36495     return 0;
36496   }
36497   {
36498     try {
36499       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36500     } catch (std::out_of_range& e) {
36501       {
36502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36503       };
36504     } catch (std::exception& e) {
36505       {
36506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36507       };
36508     } catch (...) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36511       };
36512     }
36513   }
36514   jresult = (void *)result;
36515   return jresult;
36516 }
36517
36518
36519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36520   void * jresult ;
36521   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36522   Dali::PinchGestureDetector *arg2 = 0 ;
36523   Dali::PinchGestureDetector *result = 0 ;
36524
36525   arg1 = (Dali::PinchGestureDetector *)jarg1;
36526   arg2 = (Dali::PinchGestureDetector *)jarg2;
36527   if (!arg2) {
36528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36529     return 0;
36530   }
36531   {
36532     try {
36533       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36534     } catch (std::out_of_range& e) {
36535       {
36536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36537       };
36538     } catch (std::exception& e) {
36539       {
36540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36541       };
36542     } catch (...) {
36543       {
36544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36545       };
36546     }
36547   }
36548   jresult = (void *)result;
36549   return jresult;
36550 }
36551
36552
36553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36554   void * jresult ;
36555   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36556   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36557
36558   arg1 = (Dali::PinchGestureDetector *)jarg1;
36559   {
36560     try {
36561       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36562     } catch (std::out_of_range& e) {
36563       {
36564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (std::exception& e) {
36567       {
36568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36569       };
36570     } catch (...) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36573       };
36574     }
36575   }
36576   jresult = (void *)result;
36577   return jresult;
36578 }
36579
36580
36581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36582   void * jresult ;
36583   Dali::Gesture::State arg1 ;
36584   Dali::PinchGesture *result = 0 ;
36585
36586   arg1 = (Dali::Gesture::State)jarg1;
36587   {
36588     try {
36589       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36590     } catch (std::out_of_range& e) {
36591       {
36592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36593       };
36594     } catch (std::exception& e) {
36595       {
36596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36597       };
36598     } catch (...) {
36599       {
36600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36601       };
36602     }
36603   }
36604   jresult = (void *)result;
36605   return jresult;
36606 }
36607
36608
36609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36610   void * jresult ;
36611   Dali::PinchGesture *arg1 = 0 ;
36612   Dali::PinchGesture *result = 0 ;
36613
36614   arg1 = (Dali::PinchGesture *)jarg1;
36615   if (!arg1) {
36616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36617     return 0;
36618   }
36619   {
36620     try {
36621       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36622     } catch (std::out_of_range& e) {
36623       {
36624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36625       };
36626     } catch (std::exception& e) {
36627       {
36628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36629       };
36630     } catch (...) {
36631       {
36632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36633       };
36634     }
36635   }
36636   jresult = (void *)result;
36637   return jresult;
36638 }
36639
36640
36641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36642   void * jresult ;
36643   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36644   Dali::PinchGesture *arg2 = 0 ;
36645   Dali::PinchGesture *result = 0 ;
36646
36647   arg1 = (Dali::PinchGesture *)jarg1;
36648   arg2 = (Dali::PinchGesture *)jarg2;
36649   if (!arg2) {
36650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36651     return 0;
36652   }
36653   {
36654     try {
36655       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36656     } catch (std::out_of_range& e) {
36657       {
36658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36659       };
36660     } catch (std::exception& e) {
36661       {
36662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36663       };
36664     } catch (...) {
36665       {
36666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36667       };
36668     }
36669   }
36670   jresult = (void *)result;
36671   return jresult;
36672 }
36673
36674
36675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36676   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36677
36678   arg1 = (Dali::PinchGesture *)jarg1;
36679   {
36680     try {
36681       delete arg1;
36682     } catch (std::out_of_range& e) {
36683       {
36684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36685       };
36686     } catch (std::exception& e) {
36687       {
36688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36689       };
36690     } catch (...) {
36691       {
36692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36693       };
36694     }
36695   }
36696 }
36697
36698
36699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36700   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36701   float arg2 ;
36702
36703   arg1 = (Dali::PinchGesture *)jarg1;
36704   arg2 = (float)jarg2;
36705   if (arg1) (arg1)->scale = arg2;
36706 }
36707
36708
36709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36710   float jresult ;
36711   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36712   float result;
36713
36714   arg1 = (Dali::PinchGesture *)jarg1;
36715   result = (float) ((arg1)->scale);
36716   jresult = result;
36717   return jresult;
36718 }
36719
36720
36721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36722   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36723   float arg2 ;
36724
36725   arg1 = (Dali::PinchGesture *)jarg1;
36726   arg2 = (float)jarg2;
36727   if (arg1) (arg1)->speed = arg2;
36728 }
36729
36730
36731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36732   float jresult ;
36733   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36734   float result;
36735
36736   arg1 = (Dali::PinchGesture *)jarg1;
36737   result = (float) ((arg1)->speed);
36738   jresult = result;
36739   return jresult;
36740 }
36741
36742
36743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36744   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36745   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36746
36747   arg1 = (Dali::PinchGesture *)jarg1;
36748   arg2 = (Dali::Vector2 *)jarg2;
36749   if (arg1) (arg1)->screenCenterPoint = *arg2;
36750 }
36751
36752
36753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36754   void * jresult ;
36755   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36756   Dali::Vector2 *result = 0 ;
36757
36758   arg1 = (Dali::PinchGesture *)jarg1;
36759   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36760   jresult = (void *)result;
36761   return jresult;
36762 }
36763
36764
36765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36766   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36767   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36768
36769   arg1 = (Dali::PinchGesture *)jarg1;
36770   arg2 = (Dali::Vector2 *)jarg2;
36771   if (arg1) (arg1)->localCenterPoint = *arg2;
36772 }
36773
36774
36775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36776   void * jresult ;
36777   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36778   Dali::Vector2 *result = 0 ;
36779
36780   arg1 = (Dali::PinchGesture *)jarg1;
36781   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36782   jresult = (void *)result;
36783   return jresult;
36784 }
36785
36786
36787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36788   void * jresult ;
36789   Dali::TapGestureDetector *result = 0 ;
36790
36791   {
36792     try {
36793       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36794     } catch (std::out_of_range& e) {
36795       {
36796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36797       };
36798     } catch (std::exception& e) {
36799       {
36800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36801       };
36802     } catch (...) {
36803       {
36804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36805       };
36806     }
36807   }
36808   jresult = (void *)result;
36809   return jresult;
36810 }
36811
36812
36813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36814   void * jresult ;
36815   Dali::TapGestureDetector result;
36816
36817   {
36818     try {
36819       result = Dali::TapGestureDetector::New();
36820     } catch (std::out_of_range& e) {
36821       {
36822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36823       };
36824     } catch (std::exception& e) {
36825       {
36826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36827       };
36828     } catch (...) {
36829       {
36830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36831       };
36832     }
36833   }
36834   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36835   return jresult;
36836 }
36837
36838
36839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36840   void * jresult ;
36841   unsigned int arg1 ;
36842   Dali::TapGestureDetector result;
36843
36844   arg1 = (unsigned int)jarg1;
36845   {
36846     try {
36847       result = Dali::TapGestureDetector::New(arg1);
36848     } catch (std::out_of_range& e) {
36849       {
36850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36851       };
36852     } catch (std::exception& e) {
36853       {
36854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36855       };
36856     } catch (...) {
36857       {
36858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36859       };
36860     }
36861   }
36862   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36863   return jresult;
36864 }
36865
36866
36867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36868   void * jresult ;
36869   Dali::BaseHandle arg1 ;
36870   Dali::BaseHandle *argp1 ;
36871   Dali::TapGestureDetector result;
36872
36873   argp1 = (Dali::BaseHandle *)jarg1;
36874   if (!argp1) {
36875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36876     return 0;
36877   }
36878   arg1 = *argp1;
36879   {
36880     try {
36881       result = Dali::TapGestureDetector::DownCast(arg1);
36882     } catch (std::out_of_range& e) {
36883       {
36884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36885       };
36886     } catch (std::exception& e) {
36887       {
36888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36889       };
36890     } catch (...) {
36891       {
36892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36893       };
36894     }
36895   }
36896   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36897   return jresult;
36898 }
36899
36900
36901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36902   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36903
36904   arg1 = (Dali::TapGestureDetector *)jarg1;
36905   {
36906     try {
36907       delete arg1;
36908     } catch (std::out_of_range& e) {
36909       {
36910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36911       };
36912     } catch (std::exception& e) {
36913       {
36914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36915       };
36916     } catch (...) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36919       };
36920     }
36921   }
36922 }
36923
36924
36925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36926   void * jresult ;
36927   Dali::TapGestureDetector *arg1 = 0 ;
36928   Dali::TapGestureDetector *result = 0 ;
36929
36930   arg1 = (Dali::TapGestureDetector *)jarg1;
36931   if (!arg1) {
36932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36933     return 0;
36934   }
36935   {
36936     try {
36937       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36938     } catch (std::out_of_range& e) {
36939       {
36940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36941       };
36942     } catch (std::exception& e) {
36943       {
36944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36945       };
36946     } catch (...) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36949       };
36950     }
36951   }
36952   jresult = (void *)result;
36953   return jresult;
36954 }
36955
36956
36957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36958   void * jresult ;
36959   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36960   Dali::TapGestureDetector *arg2 = 0 ;
36961   Dali::TapGestureDetector *result = 0 ;
36962
36963   arg1 = (Dali::TapGestureDetector *)jarg1;
36964   arg2 = (Dali::TapGestureDetector *)jarg2;
36965   if (!arg2) {
36966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36967     return 0;
36968   }
36969   {
36970     try {
36971       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36972     } catch (std::out_of_range& e) {
36973       {
36974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36975       };
36976     } catch (std::exception& e) {
36977       {
36978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36979       };
36980     } catch (...) {
36981       {
36982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36983       };
36984     }
36985   }
36986   jresult = (void *)result;
36987   return jresult;
36988 }
36989
36990
36991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36992   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36993   unsigned int arg2 ;
36994
36995   arg1 = (Dali::TapGestureDetector *)jarg1;
36996   arg2 = (unsigned int)jarg2;
36997   {
36998     try {
36999       (arg1)->SetMinimumTapsRequired(arg2);
37000     } catch (std::out_of_range& e) {
37001       {
37002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37003       };
37004     } catch (std::exception& e) {
37005       {
37006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37007       };
37008     } catch (...) {
37009       {
37010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37011       };
37012     }
37013   }
37014 }
37015
37016
37017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37018   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37019   unsigned int arg2 ;
37020
37021   arg1 = (Dali::TapGestureDetector *)jarg1;
37022   arg2 = (unsigned int)jarg2;
37023   {
37024     try {
37025       (arg1)->SetMaximumTapsRequired(arg2);
37026     } catch (std::out_of_range& e) {
37027       {
37028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37029       };
37030     } catch (std::exception& e) {
37031       {
37032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37033       };
37034     } catch (...) {
37035       {
37036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37037       };
37038     }
37039   }
37040 }
37041
37042
37043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37044   unsigned int jresult ;
37045   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37046   unsigned int result;
37047
37048   arg1 = (Dali::TapGestureDetector *)jarg1;
37049   {
37050     try {
37051       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37052     } catch (std::out_of_range& e) {
37053       {
37054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37055       };
37056     } catch (std::exception& e) {
37057       {
37058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37059       };
37060     } catch (...) {
37061       {
37062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37063       };
37064     }
37065   }
37066   jresult = result;
37067   return jresult;
37068 }
37069
37070
37071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37072   unsigned int jresult ;
37073   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37074   unsigned int result;
37075
37076   arg1 = (Dali::TapGestureDetector *)jarg1;
37077   {
37078     try {
37079       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37080     } catch (std::out_of_range& e) {
37081       {
37082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37083       };
37084     } catch (std::exception& e) {
37085       {
37086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37087       };
37088     } catch (...) {
37089       {
37090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37091       };
37092     }
37093   }
37094   jresult = result;
37095   return jresult;
37096 }
37097
37098
37099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37100   void * jresult ;
37101   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37102   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37103
37104   arg1 = (Dali::TapGestureDetector *)jarg1;
37105   {
37106     try {
37107       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37108     } catch (std::out_of_range& e) {
37109       {
37110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37111       };
37112     } catch (std::exception& e) {
37113       {
37114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37115       };
37116     } catch (...) {
37117       {
37118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37119       };
37120     }
37121   }
37122   jresult = (void *)result;
37123   return jresult;
37124 }
37125
37126
37127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37128   void * jresult ;
37129   Dali::TapGesture *result = 0 ;
37130
37131   {
37132     try {
37133       result = (Dali::TapGesture *)new Dali::TapGesture();
37134     } catch (std::out_of_range& e) {
37135       {
37136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (std::exception& e) {
37139       {
37140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (...) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37145       };
37146     }
37147   }
37148   jresult = (void *)result;
37149   return jresult;
37150 }
37151
37152
37153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37154   void * jresult ;
37155   Dali::TapGesture *arg1 = 0 ;
37156   Dali::TapGesture *result = 0 ;
37157
37158   arg1 = (Dali::TapGesture *)jarg1;
37159   if (!arg1) {
37160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37161     return 0;
37162   }
37163   {
37164     try {
37165       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37166     } catch (std::out_of_range& e) {
37167       {
37168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37169       };
37170     } catch (std::exception& e) {
37171       {
37172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37173       };
37174     } catch (...) {
37175       {
37176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37177       };
37178     }
37179   }
37180   jresult = (void *)result;
37181   return jresult;
37182 }
37183
37184
37185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37186   void * jresult ;
37187   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37188   Dali::TapGesture *arg2 = 0 ;
37189   Dali::TapGesture *result = 0 ;
37190
37191   arg1 = (Dali::TapGesture *)jarg1;
37192   arg2 = (Dali::TapGesture *)jarg2;
37193   if (!arg2) {
37194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37195     return 0;
37196   }
37197   {
37198     try {
37199       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37200     } catch (std::out_of_range& e) {
37201       {
37202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37203       };
37204     } catch (std::exception& e) {
37205       {
37206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37207       };
37208     } catch (...) {
37209       {
37210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37211       };
37212     }
37213   }
37214   jresult = (void *)result;
37215   return jresult;
37216 }
37217
37218
37219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37220   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37221
37222   arg1 = (Dali::TapGesture *)jarg1;
37223   {
37224     try {
37225       delete arg1;
37226     } catch (std::out_of_range& e) {
37227       {
37228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37229       };
37230     } catch (std::exception& e) {
37231       {
37232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37233       };
37234     } catch (...) {
37235       {
37236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37237       };
37238     }
37239   }
37240 }
37241
37242
37243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37244   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37245   unsigned int arg2 ;
37246
37247   arg1 = (Dali::TapGesture *)jarg1;
37248   arg2 = (unsigned int)jarg2;
37249   if (arg1) (arg1)->numberOfTaps = arg2;
37250 }
37251
37252
37253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37254   unsigned int jresult ;
37255   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37256   unsigned int result;
37257
37258   arg1 = (Dali::TapGesture *)jarg1;
37259   result = (unsigned int) ((arg1)->numberOfTaps);
37260   jresult = result;
37261   return jresult;
37262 }
37263
37264
37265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37266   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37267   unsigned int arg2 ;
37268
37269   arg1 = (Dali::TapGesture *)jarg1;
37270   arg2 = (unsigned int)jarg2;
37271   if (arg1) (arg1)->numberOfTouches = arg2;
37272 }
37273
37274
37275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37276   unsigned int jresult ;
37277   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37278   unsigned int result;
37279
37280   arg1 = (Dali::TapGesture *)jarg1;
37281   result = (unsigned int) ((arg1)->numberOfTouches);
37282   jresult = result;
37283   return jresult;
37284 }
37285
37286
37287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37288   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37289   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37290
37291   arg1 = (Dali::TapGesture *)jarg1;
37292   arg2 = (Dali::Vector2 *)jarg2;
37293   if (arg1) (arg1)->screenPoint = *arg2;
37294 }
37295
37296
37297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37298   void * jresult ;
37299   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37300   Dali::Vector2 *result = 0 ;
37301
37302   arg1 = (Dali::TapGesture *)jarg1;
37303   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37304   jresult = (void *)result;
37305   return jresult;
37306 }
37307
37308
37309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37310   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37311   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37312
37313   arg1 = (Dali::TapGesture *)jarg1;
37314   arg2 = (Dali::Vector2 *)jarg2;
37315   if (arg1) (arg1)->localPoint = *arg2;
37316 }
37317
37318
37319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37320   void * jresult ;
37321   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37322   Dali::Vector2 *result = 0 ;
37323
37324   arg1 = (Dali::TapGesture *)jarg1;
37325   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37326   jresult = (void *)result;
37327   return jresult;
37328 }
37329
37330
37331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37332   void * jresult ;
37333   Dali::AlphaFunction *result = 0 ;
37334
37335   {
37336     try {
37337       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37338     } catch (std::out_of_range& e) {
37339       {
37340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37341       };
37342     } catch (std::exception& e) {
37343       {
37344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37345       };
37346     } catch (...) {
37347       {
37348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37349       };
37350     }
37351   }
37352   jresult = (void *)result;
37353   return jresult;
37354 }
37355
37356
37357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37358   void * jresult ;
37359   Dali::AlphaFunction::BuiltinFunction arg1 ;
37360   Dali::AlphaFunction *result = 0 ;
37361
37362   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37363   {
37364     try {
37365       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37366     } catch (std::out_of_range& e) {
37367       {
37368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37369       };
37370     } catch (std::exception& e) {
37371       {
37372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37373       };
37374     } catch (...) {
37375       {
37376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37377       };
37378     }
37379   }
37380   jresult = (void *)result;
37381   return jresult;
37382 }
37383
37384
37385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37386   void * jresult ;
37387   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37388   Dali::AlphaFunction *result = 0 ;
37389
37390   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37391   {
37392     try {
37393       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37394     } catch (std::out_of_range& e) {
37395       {
37396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37397       };
37398     } catch (std::exception& e) {
37399       {
37400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37401       };
37402     } catch (...) {
37403       {
37404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37405       };
37406     }
37407   }
37408   jresult = (void *)result;
37409   return jresult;
37410 }
37411
37412
37413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37414   void * jresult ;
37415   Dali::Vector2 *arg1 = 0 ;
37416   Dali::Vector2 *arg2 = 0 ;
37417   Dali::AlphaFunction *result = 0 ;
37418
37419   arg1 = (Dali::Vector2 *)jarg1;
37420   if (!arg1) {
37421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37422     return 0;
37423   }
37424   arg2 = (Dali::Vector2 *)jarg2;
37425   if (!arg2) {
37426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37427     return 0;
37428   }
37429   {
37430     try {
37431       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37432     } catch (std::out_of_range& e) {
37433       {
37434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37435       };
37436     } catch (std::exception& e) {
37437       {
37438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37439       };
37440     } catch (...) {
37441       {
37442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37443       };
37444     }
37445   }
37446   jresult = (void *)result;
37447   return jresult;
37448 }
37449
37450
37451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37452   void * jresult ;
37453   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37454   Dali::Vector4 result;
37455
37456   arg1 = (Dali::AlphaFunction *)jarg1;
37457   {
37458     try {
37459       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37460     } catch (std::out_of_range& e) {
37461       {
37462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37463       };
37464     } catch (std::exception& e) {
37465       {
37466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37467       };
37468     } catch (...) {
37469       {
37470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37471       };
37472     }
37473   }
37474   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37475   return jresult;
37476 }
37477
37478
37479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37480   void * jresult ;
37481   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37482   Dali::AlphaFunctionPrototype result;
37483
37484   arg1 = (Dali::AlphaFunction *)jarg1;
37485   {
37486     try {
37487       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37488     } catch (std::out_of_range& e) {
37489       {
37490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37491       };
37492     } catch (std::exception& e) {
37493       {
37494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37495       };
37496     } catch (...) {
37497       {
37498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37499       };
37500     }
37501   }
37502   jresult = (void *)result;
37503   return jresult;
37504 }
37505
37506
37507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37508   int jresult ;
37509   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37510   Dali::AlphaFunction::BuiltinFunction result;
37511
37512   arg1 = (Dali::AlphaFunction *)jarg1;
37513   {
37514     try {
37515       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37516     } catch (std::out_of_range& e) {
37517       {
37518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37519       };
37520     } catch (std::exception& e) {
37521       {
37522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37523       };
37524     } catch (...) {
37525       {
37526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37527       };
37528     }
37529   }
37530   jresult = (int)result;
37531   return jresult;
37532 }
37533
37534
37535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37536   int jresult ;
37537   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37538   Dali::AlphaFunction::Mode result;
37539
37540   arg1 = (Dali::AlphaFunction *)jarg1;
37541   {
37542     try {
37543       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37544     } catch (std::out_of_range& e) {
37545       {
37546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37547       };
37548     } catch (std::exception& e) {
37549       {
37550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37551       };
37552     } catch (...) {
37553       {
37554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37555       };
37556     }
37557   }
37558   jresult = (int)result;
37559   return jresult;
37560 }
37561
37562
37563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37564   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37565
37566   arg1 = (Dali::AlphaFunction *)jarg1;
37567   {
37568     try {
37569       delete arg1;
37570     } catch (std::out_of_range& e) {
37571       {
37572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37573       };
37574     } catch (std::exception& e) {
37575       {
37576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37577       };
37578     } catch (...) {
37579       {
37580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37581       };
37582     }
37583   }
37584 }
37585
37586
37587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37588   void * jresult ;
37589   Dali::KeyFrames result;
37590
37591   {
37592     try {
37593       result = Dali::KeyFrames::New();
37594     } catch (std::out_of_range& e) {
37595       {
37596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37597       };
37598     } catch (std::exception& e) {
37599       {
37600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37601       };
37602     } catch (...) {
37603       {
37604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37605       };
37606     }
37607   }
37608   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37609   return jresult;
37610 }
37611
37612
37613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37614   void * jresult ;
37615   Dali::BaseHandle arg1 ;
37616   Dali::BaseHandle *argp1 ;
37617   Dali::KeyFrames result;
37618
37619   argp1 = (Dali::BaseHandle *)jarg1;
37620   if (!argp1) {
37621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37622     return 0;
37623   }
37624   arg1 = *argp1;
37625   {
37626     try {
37627       result = Dali::KeyFrames::DownCast(arg1);
37628     } catch (std::out_of_range& e) {
37629       {
37630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37631       };
37632     } catch (std::exception& e) {
37633       {
37634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37635       };
37636     } catch (...) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37639       };
37640     }
37641   }
37642   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37643   return jresult;
37644 }
37645
37646
37647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37648   void * jresult ;
37649   Dali::KeyFrames *result = 0 ;
37650
37651   {
37652     try {
37653       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37654     } catch (std::out_of_range& e) {
37655       {
37656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37657       };
37658     } catch (std::exception& e) {
37659       {
37660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37661       };
37662     } catch (...) {
37663       {
37664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37665       };
37666     }
37667   }
37668   jresult = (void *)result;
37669   return jresult;
37670 }
37671
37672
37673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37674   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37675
37676   arg1 = (Dali::KeyFrames *)jarg1;
37677   {
37678     try {
37679       delete arg1;
37680     } catch (std::out_of_range& e) {
37681       {
37682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37683       };
37684     } catch (std::exception& e) {
37685       {
37686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37687       };
37688     } catch (...) {
37689       {
37690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37691       };
37692     }
37693   }
37694 }
37695
37696
37697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37698   void * jresult ;
37699   Dali::KeyFrames *arg1 = 0 ;
37700   Dali::KeyFrames *result = 0 ;
37701
37702   arg1 = (Dali::KeyFrames *)jarg1;
37703   if (!arg1) {
37704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37705     return 0;
37706   }
37707   {
37708     try {
37709       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37710     } catch (std::out_of_range& e) {
37711       {
37712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37713       };
37714     } catch (std::exception& e) {
37715       {
37716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37717       };
37718     } catch (...) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37721       };
37722     }
37723   }
37724   jresult = (void *)result;
37725   return jresult;
37726 }
37727
37728
37729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37730   void * jresult ;
37731   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37732   Dali::KeyFrames *arg2 = 0 ;
37733   Dali::KeyFrames *result = 0 ;
37734
37735   arg1 = (Dali::KeyFrames *)jarg1;
37736   arg2 = (Dali::KeyFrames *)jarg2;
37737   if (!arg2) {
37738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37739     return 0;
37740   }
37741   {
37742     try {
37743       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37744     } catch (std::out_of_range& e) {
37745       {
37746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37747       };
37748     } catch (std::exception& e) {
37749       {
37750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37751       };
37752     } catch (...) {
37753       {
37754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37755       };
37756     }
37757   }
37758   jresult = (void *)result;
37759   return jresult;
37760 }
37761
37762
37763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37764   int jresult ;
37765   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37766   Dali::Property::Type result;
37767
37768   arg1 = (Dali::KeyFrames *)jarg1;
37769   {
37770     try {
37771       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37772     } catch (std::out_of_range& e) {
37773       {
37774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37775       };
37776     } catch (std::exception& e) {
37777       {
37778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37779       };
37780     } catch (...) {
37781       {
37782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37783       };
37784     }
37785   }
37786   jresult = (int)result;
37787   return jresult;
37788 }
37789
37790
37791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37792   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37793   float arg2 ;
37794   Dali::Property::Value arg3 ;
37795   Dali::Property::Value *argp3 ;
37796
37797   arg1 = (Dali::KeyFrames *)jarg1;
37798   arg2 = (float)jarg2;
37799   argp3 = (Dali::Property::Value *)jarg3;
37800   if (!argp3) {
37801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37802     return ;
37803   }
37804   arg3 = *argp3;
37805   {
37806     try {
37807       (arg1)->Add(arg2,arg3);
37808     } catch (std::out_of_range& e) {
37809       {
37810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37811       };
37812     } catch (std::exception& e) {
37813       {
37814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37815       };
37816     } catch (...) {
37817       {
37818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37819       };
37820     }
37821   }
37822 }
37823
37824
37825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37826   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37827   float arg2 ;
37828   Dali::Property::Value arg3 ;
37829   Dali::AlphaFunction arg4 ;
37830   Dali::Property::Value *argp3 ;
37831   Dali::AlphaFunction *argp4 ;
37832
37833   arg1 = (Dali::KeyFrames *)jarg1;
37834   arg2 = (float)jarg2;
37835   argp3 = (Dali::Property::Value *)jarg3;
37836   if (!argp3) {
37837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37838     return ;
37839   }
37840   arg3 = *argp3;
37841   argp4 = (Dali::AlphaFunction *)jarg4;
37842   if (!argp4) {
37843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37844     return ;
37845   }
37846   arg4 = *argp4;
37847   {
37848     try {
37849       (arg1)->Add(arg2,arg3,arg4);
37850     } catch (std::out_of_range& e) {
37851       {
37852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37853       };
37854     } catch (std::exception& e) {
37855       {
37856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37857       };
37858     } catch (...) {
37859       {
37860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37861       };
37862     }
37863   }
37864 }
37865
37866
37867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37868   int jresult ;
37869   int result;
37870
37871   result = (int)Dali::Path::Property::POINTS;
37872   jresult = (int)result;
37873   return jresult;
37874 }
37875
37876
37877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37878   int jresult ;
37879   int result;
37880
37881   result = (int)Dali::Path::Property::CONTROL_POINTS;
37882   jresult = (int)result;
37883   return jresult;
37884 }
37885
37886
37887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37888   void * jresult ;
37889   Dali::Path::Property *result = 0 ;
37890
37891   {
37892     try {
37893       result = (Dali::Path::Property *)new Dali::Path::Property();
37894     } catch (std::out_of_range& e) {
37895       {
37896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37897       };
37898     } catch (std::exception& e) {
37899       {
37900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37901       };
37902     } catch (...) {
37903       {
37904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37905       };
37906     }
37907   }
37908   jresult = (void *)result;
37909   return jresult;
37910 }
37911
37912
37913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37914   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37915
37916   arg1 = (Dali::Path::Property *)jarg1;
37917   {
37918     try {
37919       delete arg1;
37920     } catch (std::out_of_range& e) {
37921       {
37922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37923       };
37924     } catch (std::exception& e) {
37925       {
37926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37927       };
37928     } catch (...) {
37929       {
37930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37931       };
37932     }
37933   }
37934 }
37935
37936
37937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37938   void * jresult ;
37939   Dali::Path result;
37940
37941   {
37942     try {
37943       result = Dali::Path::New();
37944     } catch (std::out_of_range& e) {
37945       {
37946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37947       };
37948     } catch (std::exception& e) {
37949       {
37950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37951       };
37952     } catch (...) {
37953       {
37954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37955       };
37956     }
37957   }
37958   jresult = new Dali::Path((const Dali::Path &)result);
37959   return jresult;
37960 }
37961
37962
37963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37964   void * jresult ;
37965   Dali::BaseHandle arg1 ;
37966   Dali::BaseHandle *argp1 ;
37967   Dali::Path result;
37968
37969   argp1 = (Dali::BaseHandle *)jarg1;
37970   if (!argp1) {
37971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37972     return 0;
37973   }
37974   arg1 = *argp1;
37975   {
37976     try {
37977       result = Dali::Path::DownCast(arg1);
37978     } catch (std::out_of_range& e) {
37979       {
37980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37981       };
37982     } catch (std::exception& e) {
37983       {
37984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37985       };
37986     } catch (...) {
37987       {
37988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37989       };
37990     }
37991   }
37992   jresult = new Dali::Path((const Dali::Path &)result);
37993   return jresult;
37994 }
37995
37996
37997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37998   void * jresult ;
37999   Dali::Path *result = 0 ;
38000
38001   {
38002     try {
38003       result = (Dali::Path *)new Dali::Path();
38004     } catch (std::out_of_range& e) {
38005       {
38006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38007       };
38008     } catch (std::exception& e) {
38009       {
38010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38011       };
38012     } catch (...) {
38013       {
38014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38015       };
38016     }
38017   }
38018   jresult = (void *)result;
38019   return jresult;
38020 }
38021
38022
38023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38024   Dali::Path *arg1 = (Dali::Path *) 0 ;
38025
38026   arg1 = (Dali::Path *)jarg1;
38027   {
38028     try {
38029       delete arg1;
38030     } catch (std::out_of_range& e) {
38031       {
38032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (std::exception& e) {
38035       {
38036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38037       };
38038     } catch (...) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38041       };
38042     }
38043   }
38044 }
38045
38046
38047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38048   void * jresult ;
38049   Dali::Path *arg1 = 0 ;
38050   Dali::Path *result = 0 ;
38051
38052   arg1 = (Dali::Path *)jarg1;
38053   if (!arg1) {
38054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38055     return 0;
38056   }
38057   {
38058     try {
38059       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38060     } catch (std::out_of_range& e) {
38061       {
38062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38063       };
38064     } catch (std::exception& e) {
38065       {
38066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38067       };
38068     } catch (...) {
38069       {
38070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38071       };
38072     }
38073   }
38074   jresult = (void *)result;
38075   return jresult;
38076 }
38077
38078
38079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38080   void * jresult ;
38081   Dali::Path *arg1 = (Dali::Path *) 0 ;
38082   Dali::Path *arg2 = 0 ;
38083   Dali::Path *result = 0 ;
38084
38085   arg1 = (Dali::Path *)jarg1;
38086   arg2 = (Dali::Path *)jarg2;
38087   if (!arg2) {
38088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38089     return 0;
38090   }
38091   {
38092     try {
38093       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38094     } catch (std::out_of_range& e) {
38095       {
38096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38097       };
38098     } catch (std::exception& e) {
38099       {
38100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (...) {
38103       {
38104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38105       };
38106     }
38107   }
38108   jresult = (void *)result;
38109   return jresult;
38110 }
38111
38112
38113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38114   Dali::Path *arg1 = (Dali::Path *) 0 ;
38115   Dali::Vector3 *arg2 = 0 ;
38116
38117   arg1 = (Dali::Path *)jarg1;
38118   arg2 = (Dali::Vector3 *)jarg2;
38119   if (!arg2) {
38120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38121     return ;
38122   }
38123   {
38124     try {
38125       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38126     } catch (std::out_of_range& e) {
38127       {
38128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38129       };
38130     } catch (std::exception& e) {
38131       {
38132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38133       };
38134     } catch (...) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38137       };
38138     }
38139   }
38140 }
38141
38142
38143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38144   Dali::Path *arg1 = (Dali::Path *) 0 ;
38145   Dali::Vector3 *arg2 = 0 ;
38146
38147   arg1 = (Dali::Path *)jarg1;
38148   arg2 = (Dali::Vector3 *)jarg2;
38149   if (!arg2) {
38150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38151     return ;
38152   }
38153   {
38154     try {
38155       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38156     } catch (std::out_of_range& e) {
38157       {
38158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38159       };
38160     } catch (std::exception& e) {
38161       {
38162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38163       };
38164     } catch (...) {
38165       {
38166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38167       };
38168     }
38169   }
38170 }
38171
38172
38173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38174   Dali::Path *arg1 = (Dali::Path *) 0 ;
38175   float arg2 ;
38176
38177   arg1 = (Dali::Path *)jarg1;
38178   arg2 = (float)jarg2;
38179   {
38180     try {
38181       (arg1)->GenerateControlPoints(arg2);
38182     } catch (std::out_of_range& e) {
38183       {
38184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38185       };
38186     } catch (std::exception& e) {
38187       {
38188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38189       };
38190     } catch (...) {
38191       {
38192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38193       };
38194     }
38195   }
38196 }
38197
38198
38199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38200   Dali::Path *arg1 = (Dali::Path *) 0 ;
38201   float arg2 ;
38202   Dali::Vector3 *arg3 = 0 ;
38203   Dali::Vector3 *arg4 = 0 ;
38204
38205   arg1 = (Dali::Path *)jarg1;
38206   arg2 = (float)jarg2;
38207   arg3 = (Dali::Vector3 *)jarg3;
38208   if (!arg3) {
38209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38210     return ;
38211   }
38212   arg4 = (Dali::Vector3 *)jarg4;
38213   if (!arg4) {
38214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38215     return ;
38216   }
38217   {
38218     try {
38219       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38220     } catch (std::out_of_range& e) {
38221       {
38222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38223       };
38224     } catch (std::exception& e) {
38225       {
38226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38227       };
38228     } catch (...) {
38229       {
38230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38231       };
38232     }
38233   }
38234 }
38235
38236
38237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38238   void * jresult ;
38239   Dali::Path *arg1 = (Dali::Path *) 0 ;
38240   size_t arg2 ;
38241   Dali::Vector3 *result = 0 ;
38242
38243   arg1 = (Dali::Path *)jarg1;
38244   arg2 = (size_t)jarg2;
38245   {
38246     try {
38247       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38248     } catch (std::out_of_range& e) {
38249       {
38250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38251       };
38252     } catch (std::exception& e) {
38253       {
38254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (...) {
38257       {
38258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38259       };
38260     }
38261   }
38262   jresult = (void *)result;
38263   return jresult;
38264 }
38265
38266
38267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38268   void * jresult ;
38269   Dali::Path *arg1 = (Dali::Path *) 0 ;
38270   size_t arg2 ;
38271   Dali::Vector3 *result = 0 ;
38272
38273   arg1 = (Dali::Path *)jarg1;
38274   arg2 = (size_t)jarg2;
38275   {
38276     try {
38277       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38278     } catch (std::out_of_range& e) {
38279       {
38280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38281       };
38282     } catch (std::exception& e) {
38283       {
38284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38285       };
38286     } catch (...) {
38287       {
38288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38289       };
38290     }
38291   }
38292   jresult = (void *)result;
38293   return jresult;
38294 }
38295
38296
38297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38298   unsigned long jresult ;
38299   Dali::Path *arg1 = (Dali::Path *) 0 ;
38300   size_t result;
38301
38302   arg1 = (Dali::Path *)jarg1;
38303   {
38304     try {
38305       result = ((Dali::Path const *)arg1)->GetPointCount();
38306     } catch (std::out_of_range& e) {
38307       {
38308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38309       };
38310     } catch (std::exception& e) {
38311       {
38312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38313       };
38314     } catch (...) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38317       };
38318     }
38319   }
38320   jresult = (unsigned long)result;
38321   return jresult;
38322 }
38323
38324
38325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38326   void * jresult ;
38327   float arg1 ;
38328   Dali::TimePeriod *result = 0 ;
38329
38330   arg1 = (float)jarg1;
38331   {
38332     try {
38333       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38334     } catch (std::out_of_range& e) {
38335       {
38336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (std::exception& e) {
38339       {
38340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348   jresult = (void *)result;
38349   return jresult;
38350 }
38351
38352
38353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38354   void * jresult ;
38355   float arg1 ;
38356   float arg2 ;
38357   Dali::TimePeriod *result = 0 ;
38358
38359   arg1 = (float)jarg1;
38360   arg2 = (float)jarg2;
38361   {
38362     try {
38363       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38364     } catch (std::out_of_range& e) {
38365       {
38366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38367       };
38368     } catch (std::exception& e) {
38369       {
38370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (...) {
38373       {
38374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38375       };
38376     }
38377   }
38378   jresult = (void *)result;
38379   return jresult;
38380 }
38381
38382
38383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38384   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38385
38386   arg1 = (Dali::TimePeriod *)jarg1;
38387   {
38388     try {
38389       delete arg1;
38390     } catch (std::out_of_range& e) {
38391       {
38392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38393       };
38394     } catch (std::exception& e) {
38395       {
38396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38397       };
38398     } catch (...) {
38399       {
38400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38401       };
38402     }
38403   }
38404 }
38405
38406
38407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38408   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38409   float arg2 ;
38410
38411   arg1 = (Dali::TimePeriod *)jarg1;
38412   arg2 = (float)jarg2;
38413   if (arg1) (arg1)->delaySeconds = arg2;
38414 }
38415
38416
38417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38418   float jresult ;
38419   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38420   float result;
38421
38422   arg1 = (Dali::TimePeriod *)jarg1;
38423   result = (float) ((arg1)->delaySeconds);
38424   jresult = result;
38425   return jresult;
38426 }
38427
38428
38429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38430   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38431   float arg2 ;
38432
38433   arg1 = (Dali::TimePeriod *)jarg1;
38434   arg2 = (float)jarg2;
38435   if (arg1) (arg1)->durationSeconds = arg2;
38436 }
38437
38438
38439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38440   float jresult ;
38441   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38442   float result;
38443
38444   arg1 = (Dali::TimePeriod *)jarg1;
38445   result = (float) ((arg1)->durationSeconds);
38446   jresult = result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38452   void * jresult ;
38453   Dali::Animation *result = 0 ;
38454
38455   {
38456     try {
38457       result = (Dali::Animation *)new Dali::Animation();
38458     } catch (std::out_of_range& e) {
38459       {
38460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38461       };
38462     } catch (std::exception& e) {
38463       {
38464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38465       };
38466     } catch (...) {
38467       {
38468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38469       };
38470     }
38471   }
38472   jresult = (void *)result;
38473   return jresult;
38474 }
38475
38476
38477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38478   void * jresult ;
38479   float arg1 ;
38480   Dali::Animation result;
38481
38482   arg1 = (float)jarg1;
38483   {
38484     try {
38485       result = Dali::Animation::New(arg1);
38486     } catch (std::out_of_range& e) {
38487       {
38488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38489       };
38490     } catch (std::exception& e) {
38491       {
38492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38493       };
38494     } catch (...) {
38495       {
38496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38497       };
38498     }
38499   }
38500   jresult = new Dali::Animation((const Dali::Animation &)result);
38501   return jresult;
38502 }
38503
38504
38505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38506   void * jresult ;
38507   Dali::BaseHandle arg1 ;
38508   Dali::BaseHandle *argp1 ;
38509   Dali::Animation result;
38510
38511   argp1 = (Dali::BaseHandle *)jarg1;
38512   if (!argp1) {
38513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38514     return 0;
38515   }
38516   arg1 = *argp1;
38517   {
38518     try {
38519       result = Dali::Animation::DownCast(arg1);
38520     } catch (std::out_of_range& e) {
38521       {
38522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38523       };
38524     } catch (std::exception& e) {
38525       {
38526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38527       };
38528     } catch (...) {
38529       {
38530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38531       };
38532     }
38533   }
38534   jresult = new Dali::Animation((const Dali::Animation &)result);
38535   return jresult;
38536 }
38537
38538
38539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38540   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38541
38542   arg1 = (Dali::Animation *)jarg1;
38543   {
38544     try {
38545       delete arg1;
38546     } catch (std::out_of_range& e) {
38547       {
38548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38549       };
38550     } catch (std::exception& e) {
38551       {
38552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38553       };
38554     } catch (...) {
38555       {
38556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38557       };
38558     }
38559   }
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38564   void * jresult ;
38565   Dali::Animation *arg1 = 0 ;
38566   Dali::Animation *result = 0 ;
38567
38568   arg1 = (Dali::Animation *)jarg1;
38569   if (!arg1) {
38570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38571     return 0;
38572   }
38573   {
38574     try {
38575       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38576     } catch (std::out_of_range& e) {
38577       {
38578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (std::exception& e) {
38581       {
38582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38583       };
38584     } catch (...) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38587       };
38588     }
38589   }
38590   jresult = (void *)result;
38591   return jresult;
38592 }
38593
38594
38595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38596   void * jresult ;
38597   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38598   Dali::Animation *arg2 = 0 ;
38599   Dali::Animation *result = 0 ;
38600
38601   arg1 = (Dali::Animation *)jarg1;
38602   arg2 = (Dali::Animation *)jarg2;
38603   if (!arg2) {
38604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38605     return 0;
38606   }
38607   {
38608     try {
38609       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38610     } catch (std::out_of_range& e) {
38611       {
38612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38613       };
38614     } catch (std::exception& e) {
38615       {
38616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38617       };
38618     } catch (...) {
38619       {
38620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38621       };
38622     }
38623   }
38624   jresult = (void *)result;
38625   return jresult;
38626 }
38627
38628
38629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38630   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38631   float arg2 ;
38632
38633   arg1 = (Dali::Animation *)jarg1;
38634   arg2 = (float)jarg2;
38635   {
38636     try {
38637       (arg1)->SetDuration(arg2);
38638     } catch (std::out_of_range& e) {
38639       {
38640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38641       };
38642     } catch (std::exception& e) {
38643       {
38644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38645       };
38646     } catch (...) {
38647       {
38648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38649       };
38650     }
38651   }
38652 }
38653
38654
38655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38656   float jresult ;
38657   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38658   float result;
38659
38660   arg1 = (Dali::Animation *)jarg1;
38661   {
38662     try {
38663       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38664     } catch (std::out_of_range& e) {
38665       {
38666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38667       };
38668     } catch (std::exception& e) {
38669       {
38670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38671       };
38672     } catch (...) {
38673       {
38674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38675       };
38676     }
38677   }
38678   jresult = result;
38679   return jresult;
38680 }
38681
38682
38683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38684   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38685   bool arg2 ;
38686
38687   arg1 = (Dali::Animation *)jarg1;
38688   arg2 = jarg2 ? true : false;
38689   {
38690     try {
38691       (arg1)->SetLooping(arg2);
38692     } catch (std::out_of_range& e) {
38693       {
38694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38695       };
38696     } catch (std::exception& e) {
38697       {
38698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38699       };
38700     } catch (...) {
38701       {
38702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38703       };
38704     }
38705   }
38706 }
38707
38708
38709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38710   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38711   int arg2 ;
38712
38713   arg1 = (Dali::Animation *)jarg1;
38714   arg2 = (int)jarg2;
38715   {
38716     try {
38717       (arg1)->SetLoopCount(arg2);
38718     } catch (std::out_of_range& e) {
38719       {
38720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38721       };
38722     } catch (std::exception& e) {
38723       {
38724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38725       };
38726     } catch (...) {
38727       {
38728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38729       };
38730     }
38731   }
38732 }
38733
38734
38735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38736   int jresult ;
38737   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38738   int result;
38739
38740   arg1 = (Dali::Animation *)jarg1;
38741   {
38742     try {
38743       result = (int)(arg1)->GetLoopCount();
38744     } catch (std::out_of_range& e) {
38745       {
38746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38747       };
38748     } catch (std::exception& e) {
38749       {
38750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38751       };
38752     } catch (...) {
38753       {
38754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38755       };
38756     }
38757   }
38758   jresult = result;
38759   return jresult;
38760 }
38761
38762
38763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38764   int jresult ;
38765   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38766   int result;
38767
38768   arg1 = (Dali::Animation *)jarg1;
38769   {
38770     try {
38771       result = (int)(arg1)->GetCurrentLoop();
38772     } catch (std::out_of_range& e) {
38773       {
38774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38775       };
38776     } catch (std::exception& e) {
38777       {
38778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38779       };
38780     } catch (...) {
38781       {
38782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38783       };
38784     }
38785   }
38786   jresult = result;
38787   return jresult;
38788 }
38789
38790
38791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38792   unsigned int jresult ;
38793   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38794   bool result;
38795
38796   arg1 = (Dali::Animation *)jarg1;
38797   {
38798     try {
38799       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38800     } catch (std::out_of_range& e) {
38801       {
38802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38803       };
38804     } catch (std::exception& e) {
38805       {
38806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38807       };
38808     } catch (...) {
38809       {
38810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38811       };
38812     }
38813   }
38814   jresult = result;
38815   return jresult;
38816 }
38817
38818
38819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38820   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38821   Dali::Animation::EndAction arg2 ;
38822
38823   arg1 = (Dali::Animation *)jarg1;
38824   arg2 = (Dali::Animation::EndAction)jarg2;
38825   {
38826     try {
38827       (arg1)->SetEndAction(arg2);
38828     } catch (std::out_of_range& e) {
38829       {
38830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38831       };
38832     } catch (std::exception& e) {
38833       {
38834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38835       };
38836     } catch (...) {
38837       {
38838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38839       };
38840     }
38841   }
38842 }
38843
38844
38845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38846   int jresult ;
38847   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38848   Dali::Animation::EndAction result;
38849
38850   arg1 = (Dali::Animation *)jarg1;
38851   {
38852     try {
38853       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38854     } catch (std::out_of_range& e) {
38855       {
38856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38857       };
38858     } catch (std::exception& e) {
38859       {
38860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38861       };
38862     } catch (...) {
38863       {
38864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38865       };
38866     }
38867   }
38868   jresult = (int)result;
38869   return jresult;
38870 }
38871
38872
38873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38874   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38875   Dali::Animation::EndAction arg2 ;
38876
38877   arg1 = (Dali::Animation *)jarg1;
38878   arg2 = (Dali::Animation::EndAction)jarg2;
38879   {
38880     try {
38881       (arg1)->SetDisconnectAction(arg2);
38882     } catch (std::out_of_range& e) {
38883       {
38884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38885       };
38886     } catch (std::exception& e) {
38887       {
38888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38889       };
38890     } catch (...) {
38891       {
38892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38893       };
38894     }
38895   }
38896 }
38897
38898
38899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38900   int jresult ;
38901   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38902   Dali::Animation::EndAction result;
38903
38904   arg1 = (Dali::Animation *)jarg1;
38905   {
38906     try {
38907       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38908     } catch (std::out_of_range& e) {
38909       {
38910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38911       };
38912     } catch (std::exception& e) {
38913       {
38914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38915       };
38916     } catch (...) {
38917       {
38918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38919       };
38920     }
38921   }
38922   jresult = (int)result;
38923   return jresult;
38924 }
38925
38926
38927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38928   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38929   Dali::AlphaFunction arg2 ;
38930   Dali::AlphaFunction *argp2 ;
38931
38932   arg1 = (Dali::Animation *)jarg1;
38933   argp2 = (Dali::AlphaFunction *)jarg2;
38934   if (!argp2) {
38935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38936     return ;
38937   }
38938   arg2 = *argp2;
38939   {
38940     try {
38941       (arg1)->SetDefaultAlphaFunction(arg2);
38942     } catch (std::out_of_range& e) {
38943       {
38944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38945       };
38946     } catch (std::exception& e) {
38947       {
38948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38949       };
38950     } catch (...) {
38951       {
38952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38953       };
38954     }
38955   }
38956 }
38957
38958
38959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38960   void * jresult ;
38961   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38962   Dali::AlphaFunction result;
38963
38964   arg1 = (Dali::Animation *)jarg1;
38965   {
38966     try {
38967       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38968     } catch (std::out_of_range& e) {
38969       {
38970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38971       };
38972     } catch (std::exception& e) {
38973       {
38974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38975       };
38976     } catch (...) {
38977       {
38978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38979       };
38980     }
38981   }
38982   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38983   return jresult;
38984 }
38985
38986
38987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38988   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38989   float arg2 ;
38990
38991   arg1 = (Dali::Animation *)jarg1;
38992   arg2 = (float)jarg2;
38993   {
38994     try {
38995       (arg1)->SetCurrentProgress(arg2);
38996     } catch (std::out_of_range& e) {
38997       {
38998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38999       };
39000     } catch (std::exception& e) {
39001       {
39002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39003       };
39004     } catch (...) {
39005       {
39006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39007       };
39008     }
39009   }
39010 }
39011
39012
39013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39014   float jresult ;
39015   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39016   float result;
39017
39018   arg1 = (Dali::Animation *)jarg1;
39019   {
39020     try {
39021       result = (float)(arg1)->GetCurrentProgress();
39022     } catch (std::out_of_range& e) {
39023       {
39024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39025       };
39026     } catch (std::exception& e) {
39027       {
39028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39029       };
39030     } catch (...) {
39031       {
39032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39033       };
39034     }
39035   }
39036   jresult = result;
39037   return jresult;
39038 }
39039
39040
39041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39042   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39043   float arg2 ;
39044
39045   arg1 = (Dali::Animation *)jarg1;
39046   arg2 = (float)jarg2;
39047   {
39048     try {
39049       (arg1)->SetSpeedFactor(arg2);
39050     } catch (std::out_of_range& e) {
39051       {
39052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39053       };
39054     } catch (std::exception& e) {
39055       {
39056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39057       };
39058     } catch (...) {
39059       {
39060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39061       };
39062     }
39063   }
39064 }
39065
39066
39067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39068   float jresult ;
39069   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39070   float result;
39071
39072   arg1 = (Dali::Animation *)jarg1;
39073   {
39074     try {
39075       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39076     } catch (std::out_of_range& e) {
39077       {
39078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39079       };
39080     } catch (std::exception& e) {
39081       {
39082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39083       };
39084     } catch (...) {
39085       {
39086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39087       };
39088     }
39089   }
39090   jresult = result;
39091   return jresult;
39092 }
39093
39094
39095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39096   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39097   Dali::Vector2 *arg2 = 0 ;
39098
39099   arg1 = (Dali::Animation *)jarg1;
39100   arg2 = (Dali::Vector2 *)jarg2;
39101   if (!arg2) {
39102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39103     return ;
39104   }
39105   {
39106     try {
39107       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39108     } catch (std::out_of_range& e) {
39109       {
39110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39111       };
39112     } catch (std::exception& e) {
39113       {
39114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39115       };
39116     } catch (...) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39119       };
39120     }
39121   }
39122 }
39123
39124
39125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39126   void * jresult ;
39127   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39128   Dali::Vector2 result;
39129
39130   arg1 = (Dali::Animation *)jarg1;
39131   {
39132     try {
39133       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39134     } catch (std::out_of_range& e) {
39135       {
39136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39137       };
39138     } catch (std::exception& e) {
39139       {
39140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39141       };
39142     } catch (...) {
39143       {
39144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39145       };
39146     }
39147   }
39148   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39149   return jresult;
39150 }
39151
39152
39153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39154   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39155
39156   arg1 = (Dali::Animation *)jarg1;
39157   {
39158     try {
39159       (arg1)->Play();
39160     } catch (std::out_of_range& e) {
39161       {
39162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39163       };
39164     } catch (std::exception& e) {
39165       {
39166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39167       };
39168     } catch (...) {
39169       {
39170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39171       };
39172     }
39173   }
39174 }
39175
39176
39177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39178   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39179   float arg2 ;
39180
39181   arg1 = (Dali::Animation *)jarg1;
39182   arg2 = (float)jarg2;
39183   {
39184     try {
39185       (arg1)->PlayFrom(arg2);
39186     } catch (std::out_of_range& e) {
39187       {
39188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39189       };
39190     } catch (std::exception& e) {
39191       {
39192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (...) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39197       };
39198     }
39199   }
39200 }
39201
39202
39203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39204   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39205
39206   arg1 = (Dali::Animation *)jarg1;
39207   {
39208     try {
39209       (arg1)->Pause();
39210     } catch (std::out_of_range& e) {
39211       {
39212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39213       };
39214     } catch (std::exception& e) {
39215       {
39216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39217       };
39218     } catch (...) {
39219       {
39220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39221       };
39222     }
39223   }
39224 }
39225
39226
39227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39228   int jresult ;
39229   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39230   Dali::Animation::State result;
39231
39232   arg1 = (Dali::Animation *)jarg1;
39233   {
39234     try {
39235       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39236     } catch (std::out_of_range& e) {
39237       {
39238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39239       };
39240     } catch (std::exception& e) {
39241       {
39242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39243       };
39244     } catch (...) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39247       };
39248     }
39249   }
39250   jresult = (int)result;
39251   return jresult;
39252 }
39253
39254
39255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39256   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39257
39258   arg1 = (Dali::Animation *)jarg1;
39259   {
39260     try {
39261       (arg1)->Stop();
39262     } catch (std::out_of_range& e) {
39263       {
39264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39265       };
39266     } catch (std::exception& e) {
39267       {
39268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39269       };
39270     } catch (...) {
39271       {
39272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39273       };
39274     }
39275   }
39276 }
39277
39278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) {
39279   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39280
39281   Dali::Animation arg1 = *argp1;
39282   float arg2 = (float)jarg2;
39283
39284   {
39285     try {
39286       Dali::DevelAnimation::SetProgressNotification(arg1, arg2);
39287     } catch (std::out_of_range& e) {
39288       {
39289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39290       };
39291     } catch (std::exception& e) {
39292       {
39293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39294       };
39295     } catch (...) {
39296       {
39297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39298       };
39299     }
39300   }
39301 }
39302
39303
39304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) {
39305   float jresult ;
39306   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39307   float result;
39308
39309   Dali::Animation arg1 = *argp1;
39310   {
39311     try {
39312       result = (float)Dali::DevelAnimation::GetProgressNotification(arg1);
39313     } catch (std::out_of_range& e) {
39314       {
39315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39316       };
39317     } catch (std::exception& e) {
39318       {
39319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39320       };
39321     } catch (...) {
39322       {
39323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39324       };
39325     }
39326   }
39327   jresult = result;
39328   return jresult;
39329 }
39330
39331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39332   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39333
39334   arg1 = (Dali::Animation *)jarg1;
39335   {
39336     try {
39337       (arg1)->Clear();
39338     } catch (std::out_of_range& e) {
39339       {
39340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39341       };
39342     } catch (std::exception& e) {
39343       {
39344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39345       };
39346     } catch (...) {
39347       {
39348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39349       };
39350     }
39351   }
39352 }
39353
39354
39355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39356   void * jresult ;
39357   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39358   Dali::Animation::AnimationSignalType *result = 0 ;
39359
39360   arg1 = (Dali::Animation *)jarg1;
39361   {
39362     try {
39363       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39364     } catch (std::out_of_range& e) {
39365       {
39366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39367       };
39368     } catch (std::exception& e) {
39369       {
39370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39371       };
39372     } catch (...) {
39373       {
39374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39375       };
39376     }
39377   }
39378   jresult = (void *)result;
39379   return jresult;
39380 }
39381
39382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) {
39383   void * jresult ;
39384   Dali::Animation* argp1 = (Dali::Animation*) jarg1 ;
39385   Dali::Animation::AnimationSignalType *result = 0 ;
39386
39387   Dali::Animation arg1 = *argp1;
39388   {
39389     try {
39390       result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1);
39391     } catch (std::out_of_range& e) {
39392       {
39393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39394       };
39395     } catch (std::exception& e) {
39396       {
39397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39398       };
39399     } catch (...) {
39400       {
39401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39402       };
39403     }
39404   }
39405   jresult = (void *)result;
39406   return jresult;
39407 }
39408
39409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39410   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39411   SwigValueWrapper< Dali::Property > arg2 ;
39412   Dali::Property::Value arg3 ;
39413   Dali::Property *argp2 ;
39414   Dali::Property::Value *argp3 ;
39415
39416   arg1 = (Dali::Animation *)jarg1;
39417   argp2 = (Dali::Property *)jarg2;
39418   if (!argp2) {
39419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39420     return ;
39421   }
39422   arg2 = *argp2;
39423   argp3 = (Dali::Property::Value *)jarg3;
39424   if (!argp3) {
39425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39426     return ;
39427   }
39428   arg3 = *argp3;
39429   {
39430     try {
39431       (arg1)->AnimateBy(arg2,arg3);
39432     } catch (std::out_of_range& e) {
39433       {
39434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39435       };
39436     } catch (std::exception& e) {
39437       {
39438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39439       };
39440     } catch (...) {
39441       {
39442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39443       };
39444     }
39445   }
39446 }
39447
39448
39449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39450   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39451   SwigValueWrapper< Dali::Property > arg2 ;
39452   Dali::Property::Value arg3 ;
39453   Dali::AlphaFunction arg4 ;
39454   Dali::Property *argp2 ;
39455   Dali::Property::Value *argp3 ;
39456   Dali::AlphaFunction *argp4 ;
39457
39458   arg1 = (Dali::Animation *)jarg1;
39459   argp2 = (Dali::Property *)jarg2;
39460   if (!argp2) {
39461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39462     return ;
39463   }
39464   arg2 = *argp2;
39465   argp3 = (Dali::Property::Value *)jarg3;
39466   if (!argp3) {
39467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39468     return ;
39469   }
39470   arg3 = *argp3;
39471   argp4 = (Dali::AlphaFunction *)jarg4;
39472   if (!argp4) {
39473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39474     return ;
39475   }
39476   arg4 = *argp4;
39477   {
39478     try {
39479       (arg1)->AnimateBy(arg2,arg3,arg4);
39480     } catch (std::out_of_range& e) {
39481       {
39482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39483       };
39484     } catch (std::exception& e) {
39485       {
39486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39487       };
39488     } catch (...) {
39489       {
39490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39491       };
39492     }
39493   }
39494 }
39495
39496
39497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39498   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39499   SwigValueWrapper< Dali::Property > arg2 ;
39500   Dali::Property::Value arg3 ;
39501   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39502   Dali::Property *argp2 ;
39503   Dali::Property::Value *argp3 ;
39504   Dali::TimePeriod *argp4 ;
39505
39506   arg1 = (Dali::Animation *)jarg1;
39507   argp2 = (Dali::Property *)jarg2;
39508   if (!argp2) {
39509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39510     return ;
39511   }
39512   arg2 = *argp2;
39513   argp3 = (Dali::Property::Value *)jarg3;
39514   if (!argp3) {
39515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39516     return ;
39517   }
39518   arg3 = *argp3;
39519   argp4 = (Dali::TimePeriod *)jarg4;
39520   if (!argp4) {
39521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39522     return ;
39523   }
39524   arg4 = *argp4;
39525   {
39526     try {
39527       (arg1)->AnimateBy(arg2,arg3,arg4);
39528     } catch (std::out_of_range& e) {
39529       {
39530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39531       };
39532     } catch (std::exception& e) {
39533       {
39534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39535       };
39536     } catch (...) {
39537       {
39538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39539       };
39540     }
39541   }
39542 }
39543
39544
39545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39546   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39547   SwigValueWrapper< Dali::Property > arg2 ;
39548   Dali::Property::Value arg3 ;
39549   Dali::AlphaFunction arg4 ;
39550   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39551   Dali::Property *argp2 ;
39552   Dali::Property::Value *argp3 ;
39553   Dali::AlphaFunction *argp4 ;
39554   Dali::TimePeriod *argp5 ;
39555
39556   arg1 = (Dali::Animation *)jarg1;
39557   argp2 = (Dali::Property *)jarg2;
39558   if (!argp2) {
39559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39560     return ;
39561   }
39562   arg2 = *argp2;
39563   argp3 = (Dali::Property::Value *)jarg3;
39564   if (!argp3) {
39565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39566     return ;
39567   }
39568   arg3 = *argp3;
39569   argp4 = (Dali::AlphaFunction *)jarg4;
39570   if (!argp4) {
39571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39572     return ;
39573   }
39574   arg4 = *argp4;
39575   argp5 = (Dali::TimePeriod *)jarg5;
39576   if (!argp5) {
39577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39578     return ;
39579   }
39580   arg5 = *argp5;
39581   {
39582     try {
39583       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39584     } catch (std::out_of_range& e) {
39585       {
39586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39587       };
39588     } catch (std::exception& e) {
39589       {
39590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39591       };
39592     } catch (...) {
39593       {
39594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39595       };
39596     }
39597   }
39598 }
39599
39600
39601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39602   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39603   SwigValueWrapper< Dali::Property > arg2 ;
39604   Dali::Property::Value arg3 ;
39605   Dali::Property *argp2 ;
39606   Dali::Property::Value *argp3 ;
39607
39608   arg1 = (Dali::Animation *)jarg1;
39609   argp2 = (Dali::Property *)jarg2;
39610   if (!argp2) {
39611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39612     return ;
39613   }
39614   arg2 = *argp2;
39615   argp3 = (Dali::Property::Value *)jarg3;
39616   if (!argp3) {
39617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39618     return ;
39619   }
39620   arg3 = *argp3;
39621   {
39622     try {
39623       (arg1)->AnimateTo(arg2,arg3);
39624     } catch (std::out_of_range& e) {
39625       {
39626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39627       };
39628     } catch (std::exception& e) {
39629       {
39630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39631       };
39632     } catch (...) {
39633       {
39634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39635       };
39636     }
39637   }
39638 }
39639
39640
39641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39642   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39643   SwigValueWrapper< Dali::Property > arg2 ;
39644   Dali::Property::Value arg3 ;
39645   Dali::AlphaFunction arg4 ;
39646   Dali::Property *argp2 ;
39647   Dali::Property::Value *argp3 ;
39648   Dali::AlphaFunction *argp4 ;
39649
39650   arg1 = (Dali::Animation *)jarg1;
39651   argp2 = (Dali::Property *)jarg2;
39652   if (!argp2) {
39653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39654     return ;
39655   }
39656   arg2 = *argp2;
39657   argp3 = (Dali::Property::Value *)jarg3;
39658   if (!argp3) {
39659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39660     return ;
39661   }
39662   arg3 = *argp3;
39663   argp4 = (Dali::AlphaFunction *)jarg4;
39664   if (!argp4) {
39665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39666     return ;
39667   }
39668   arg4 = *argp4;
39669   {
39670     try {
39671       (arg1)->AnimateTo(arg2,arg3,arg4);
39672     } catch (std::out_of_range& e) {
39673       {
39674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39675       };
39676     } catch (std::exception& e) {
39677       {
39678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39679       };
39680     } catch (...) {
39681       {
39682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39683       };
39684     }
39685   }
39686 }
39687
39688
39689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39690   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39691   SwigValueWrapper< Dali::Property > arg2 ;
39692   Dali::Property::Value arg3 ;
39693   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39694   Dali::Property *argp2 ;
39695   Dali::Property::Value *argp3 ;
39696   Dali::TimePeriod *argp4 ;
39697
39698   arg1 = (Dali::Animation *)jarg1;
39699   argp2 = (Dali::Property *)jarg2;
39700   if (!argp2) {
39701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39702     return ;
39703   }
39704   arg2 = *argp2;
39705   argp3 = (Dali::Property::Value *)jarg3;
39706   if (!argp3) {
39707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39708     return ;
39709   }
39710   arg3 = *argp3;
39711   argp4 = (Dali::TimePeriod *)jarg4;
39712   if (!argp4) {
39713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39714     return ;
39715   }
39716   arg4 = *argp4;
39717   {
39718     try {
39719       (arg1)->AnimateTo(arg2,arg3,arg4);
39720     } catch (std::out_of_range& e) {
39721       {
39722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39723       };
39724     } catch (std::exception& e) {
39725       {
39726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39727       };
39728     } catch (...) {
39729       {
39730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39731       };
39732     }
39733   }
39734 }
39735
39736
39737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39738   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39739   SwigValueWrapper< Dali::Property > arg2 ;
39740   Dali::Property::Value arg3 ;
39741   Dali::AlphaFunction arg4 ;
39742   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39743   Dali::Property *argp2 ;
39744   Dali::Property::Value *argp3 ;
39745   Dali::AlphaFunction *argp4 ;
39746   Dali::TimePeriod *argp5 ;
39747
39748   arg1 = (Dali::Animation *)jarg1;
39749   argp2 = (Dali::Property *)jarg2;
39750   if (!argp2) {
39751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39752     return ;
39753   }
39754   arg2 = *argp2;
39755   argp3 = (Dali::Property::Value *)jarg3;
39756   if (!argp3) {
39757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39758     return ;
39759   }
39760   arg3 = *argp3;
39761   argp4 = (Dali::AlphaFunction *)jarg4;
39762   if (!argp4) {
39763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39764     return ;
39765   }
39766   arg4 = *argp4;
39767   argp5 = (Dali::TimePeriod *)jarg5;
39768   if (!argp5) {
39769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39770     return ;
39771   }
39772   arg5 = *argp5;
39773   {
39774     try {
39775       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39776     } catch (std::out_of_range& e) {
39777       {
39778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39779       };
39780     } catch (std::exception& e) {
39781       {
39782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39783       };
39784     } catch (...) {
39785       {
39786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39787       };
39788     }
39789   }
39790 }
39791
39792
39793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39794   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39795   SwigValueWrapper< Dali::Property > arg2 ;
39796   Dali::KeyFrames *arg3 = 0 ;
39797   Dali::Property *argp2 ;
39798
39799   arg1 = (Dali::Animation *)jarg1;
39800   argp2 = (Dali::Property *)jarg2;
39801   if (!argp2) {
39802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39803     return ;
39804   }
39805   arg2 = *argp2;
39806   arg3 = (Dali::KeyFrames *)jarg3;
39807   if (!arg3) {
39808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39809     return ;
39810   }
39811   {
39812     try {
39813       (arg1)->AnimateBetween(arg2,*arg3);
39814     } catch (std::out_of_range& e) {
39815       {
39816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39817       };
39818     } catch (std::exception& e) {
39819       {
39820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39821       };
39822     } catch (...) {
39823       {
39824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39825       };
39826     }
39827   }
39828 }
39829
39830
39831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39832   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39833   SwigValueWrapper< Dali::Property > arg2 ;
39834   Dali::KeyFrames *arg3 = 0 ;
39835   Dali::Animation::Interpolation arg4 ;
39836   Dali::Property *argp2 ;
39837
39838   arg1 = (Dali::Animation *)jarg1;
39839   argp2 = (Dali::Property *)jarg2;
39840   if (!argp2) {
39841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39842     return ;
39843   }
39844   arg2 = *argp2;
39845   arg3 = (Dali::KeyFrames *)jarg3;
39846   if (!arg3) {
39847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39848     return ;
39849   }
39850   arg4 = (Dali::Animation::Interpolation)jarg4;
39851   {
39852     try {
39853       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39854     } catch (std::out_of_range& e) {
39855       {
39856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39857       };
39858     } catch (std::exception& e) {
39859       {
39860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39861       };
39862     } catch (...) {
39863       {
39864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39865       };
39866     }
39867   }
39868 }
39869
39870
39871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39872   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39873   SwigValueWrapper< Dali::Property > arg2 ;
39874   Dali::KeyFrames *arg3 = 0 ;
39875   Dali::AlphaFunction arg4 ;
39876   Dali::Property *argp2 ;
39877   Dali::AlphaFunction *argp4 ;
39878
39879   arg1 = (Dali::Animation *)jarg1;
39880   argp2 = (Dali::Property *)jarg2;
39881   if (!argp2) {
39882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39883     return ;
39884   }
39885   arg2 = *argp2;
39886   arg3 = (Dali::KeyFrames *)jarg3;
39887   if (!arg3) {
39888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39889     return ;
39890   }
39891   argp4 = (Dali::AlphaFunction *)jarg4;
39892   if (!argp4) {
39893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39894     return ;
39895   }
39896   arg4 = *argp4;
39897   {
39898     try {
39899       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39900     } catch (std::out_of_range& e) {
39901       {
39902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39903       };
39904     } catch (std::exception& e) {
39905       {
39906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39907       };
39908     } catch (...) {
39909       {
39910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39911       };
39912     }
39913   }
39914 }
39915
39916
39917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39918   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39919   SwigValueWrapper< Dali::Property > arg2 ;
39920   Dali::KeyFrames *arg3 = 0 ;
39921   Dali::AlphaFunction arg4 ;
39922   Dali::Animation::Interpolation arg5 ;
39923   Dali::Property *argp2 ;
39924   Dali::AlphaFunction *argp4 ;
39925
39926   arg1 = (Dali::Animation *)jarg1;
39927   argp2 = (Dali::Property *)jarg2;
39928   if (!argp2) {
39929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39930     return ;
39931   }
39932   arg2 = *argp2;
39933   arg3 = (Dali::KeyFrames *)jarg3;
39934   if (!arg3) {
39935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39936     return ;
39937   }
39938   argp4 = (Dali::AlphaFunction *)jarg4;
39939   if (!argp4) {
39940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39941     return ;
39942   }
39943   arg4 = *argp4;
39944   arg5 = (Dali::Animation::Interpolation)jarg5;
39945   {
39946     try {
39947       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39948     } catch (std::out_of_range& e) {
39949       {
39950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39951       };
39952     } catch (std::exception& e) {
39953       {
39954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39955       };
39956     } catch (...) {
39957       {
39958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39959       };
39960     }
39961   }
39962 }
39963
39964
39965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39966   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39967   SwigValueWrapper< Dali::Property > arg2 ;
39968   Dali::KeyFrames *arg3 = 0 ;
39969   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39970   Dali::Property *argp2 ;
39971   Dali::TimePeriod *argp4 ;
39972
39973   arg1 = (Dali::Animation *)jarg1;
39974   argp2 = (Dali::Property *)jarg2;
39975   if (!argp2) {
39976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39977     return ;
39978   }
39979   arg2 = *argp2;
39980   arg3 = (Dali::KeyFrames *)jarg3;
39981   if (!arg3) {
39982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39983     return ;
39984   }
39985   argp4 = (Dali::TimePeriod *)jarg4;
39986   if (!argp4) {
39987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39988     return ;
39989   }
39990   arg4 = *argp4;
39991   {
39992     try {
39993       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39994     } catch (std::out_of_range& e) {
39995       {
39996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39997       };
39998     } catch (std::exception& e) {
39999       {
40000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40001       };
40002     } catch (...) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40005       };
40006     }
40007   }
40008 }
40009
40010
40011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40012   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40013   SwigValueWrapper< Dali::Property > arg2 ;
40014   Dali::KeyFrames *arg3 = 0 ;
40015   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40016   Dali::Animation::Interpolation arg5 ;
40017   Dali::Property *argp2 ;
40018   Dali::TimePeriod *argp4 ;
40019
40020   arg1 = (Dali::Animation *)jarg1;
40021   argp2 = (Dali::Property *)jarg2;
40022   if (!argp2) {
40023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40024     return ;
40025   }
40026   arg2 = *argp2;
40027   arg3 = (Dali::KeyFrames *)jarg3;
40028   if (!arg3) {
40029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40030     return ;
40031   }
40032   argp4 = (Dali::TimePeriod *)jarg4;
40033   if (!argp4) {
40034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40035     return ;
40036   }
40037   arg4 = *argp4;
40038   arg5 = (Dali::Animation::Interpolation)jarg5;
40039   {
40040     try {
40041       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40042     } catch (std::out_of_range& e) {
40043       {
40044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40045       };
40046     } catch (std::exception& e) {
40047       {
40048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40049       };
40050     } catch (...) {
40051       {
40052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40053       };
40054     }
40055   }
40056 }
40057
40058
40059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40060   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40061   SwigValueWrapper< Dali::Property > arg2 ;
40062   Dali::KeyFrames *arg3 = 0 ;
40063   Dali::AlphaFunction arg4 ;
40064   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40065   Dali::Property *argp2 ;
40066   Dali::AlphaFunction *argp4 ;
40067   Dali::TimePeriod *argp5 ;
40068
40069   arg1 = (Dali::Animation *)jarg1;
40070   argp2 = (Dali::Property *)jarg2;
40071   if (!argp2) {
40072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40073     return ;
40074   }
40075   arg2 = *argp2;
40076   arg3 = (Dali::KeyFrames *)jarg3;
40077   if (!arg3) {
40078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40079     return ;
40080   }
40081   argp4 = (Dali::AlphaFunction *)jarg4;
40082   if (!argp4) {
40083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40084     return ;
40085   }
40086   arg4 = *argp4;
40087   argp5 = (Dali::TimePeriod *)jarg5;
40088   if (!argp5) {
40089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40090     return ;
40091   }
40092   arg5 = *argp5;
40093   {
40094     try {
40095       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40096     } catch (std::out_of_range& e) {
40097       {
40098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40099       };
40100     } catch (std::exception& e) {
40101       {
40102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40103       };
40104     } catch (...) {
40105       {
40106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40107       };
40108     }
40109   }
40110 }
40111
40112
40113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40114   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40115   SwigValueWrapper< Dali::Property > arg2 ;
40116   Dali::KeyFrames *arg3 = 0 ;
40117   Dali::AlphaFunction arg4 ;
40118   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40119   Dali::Animation::Interpolation arg6 ;
40120   Dali::Property *argp2 ;
40121   Dali::AlphaFunction *argp4 ;
40122   Dali::TimePeriod *argp5 ;
40123
40124   arg1 = (Dali::Animation *)jarg1;
40125   argp2 = (Dali::Property *)jarg2;
40126   if (!argp2) {
40127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40128     return ;
40129   }
40130   arg2 = *argp2;
40131   arg3 = (Dali::KeyFrames *)jarg3;
40132   if (!arg3) {
40133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40134     return ;
40135   }
40136   argp4 = (Dali::AlphaFunction *)jarg4;
40137   if (!argp4) {
40138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40139     return ;
40140   }
40141   arg4 = *argp4;
40142   argp5 = (Dali::TimePeriod *)jarg5;
40143   if (!argp5) {
40144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40145     return ;
40146   }
40147   arg5 = *argp5;
40148   arg6 = (Dali::Animation::Interpolation)jarg6;
40149   {
40150     try {
40151       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40152     } catch (std::out_of_range& e) {
40153       {
40154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40155       };
40156     } catch (std::exception& e) {
40157       {
40158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40159       };
40160     } catch (...) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40163       };
40164     }
40165   }
40166 }
40167
40168
40169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40170   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40171   Dali::Actor arg2 ;
40172   Dali::Path arg3 ;
40173   Dali::Vector3 *arg4 = 0 ;
40174   Dali::Actor *argp2 ;
40175   Dali::Path *argp3 ;
40176
40177   arg1 = (Dali::Animation *)jarg1;
40178   argp2 = (Dali::Actor *)jarg2;
40179   if (!argp2) {
40180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40181     return ;
40182   }
40183   arg2 = *argp2;
40184   argp3 = (Dali::Path *)jarg3;
40185   if (!argp3) {
40186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40187     return ;
40188   }
40189   arg3 = *argp3;
40190   arg4 = (Dali::Vector3 *)jarg4;
40191   if (!arg4) {
40192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40193     return ;
40194   }
40195   {
40196     try {
40197       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40198     } catch (std::out_of_range& e) {
40199       {
40200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40201       };
40202     } catch (std::exception& e) {
40203       {
40204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40205       };
40206     } catch (...) {
40207       {
40208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40209       };
40210     }
40211   }
40212 }
40213
40214
40215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40216   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40217   Dali::Actor arg2 ;
40218   Dali::Path arg3 ;
40219   Dali::Vector3 *arg4 = 0 ;
40220   Dali::AlphaFunction arg5 ;
40221   Dali::Actor *argp2 ;
40222   Dali::Path *argp3 ;
40223   Dali::AlphaFunction *argp5 ;
40224
40225   arg1 = (Dali::Animation *)jarg1;
40226   argp2 = (Dali::Actor *)jarg2;
40227   if (!argp2) {
40228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40229     return ;
40230   }
40231   arg2 = *argp2;
40232   argp3 = (Dali::Path *)jarg3;
40233   if (!argp3) {
40234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40235     return ;
40236   }
40237   arg3 = *argp3;
40238   arg4 = (Dali::Vector3 *)jarg4;
40239   if (!arg4) {
40240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40241     return ;
40242   }
40243   argp5 = (Dali::AlphaFunction *)jarg5;
40244   if (!argp5) {
40245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40246     return ;
40247   }
40248   arg5 = *argp5;
40249   {
40250     try {
40251       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40252     } catch (std::out_of_range& e) {
40253       {
40254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40255       };
40256     } catch (std::exception& e) {
40257       {
40258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40259       };
40260     } catch (...) {
40261       {
40262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40263       };
40264     }
40265   }
40266 }
40267
40268
40269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40270   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40271   Dali::Actor arg2 ;
40272   Dali::Path arg3 ;
40273   Dali::Vector3 *arg4 = 0 ;
40274   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40275   Dali::Actor *argp2 ;
40276   Dali::Path *argp3 ;
40277   Dali::TimePeriod *argp5 ;
40278
40279   arg1 = (Dali::Animation *)jarg1;
40280   argp2 = (Dali::Actor *)jarg2;
40281   if (!argp2) {
40282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40283     return ;
40284   }
40285   arg2 = *argp2;
40286   argp3 = (Dali::Path *)jarg3;
40287   if (!argp3) {
40288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40289     return ;
40290   }
40291   arg3 = *argp3;
40292   arg4 = (Dali::Vector3 *)jarg4;
40293   if (!arg4) {
40294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40295     return ;
40296   }
40297   argp5 = (Dali::TimePeriod *)jarg5;
40298   if (!argp5) {
40299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40300     return ;
40301   }
40302   arg5 = *argp5;
40303   {
40304     try {
40305       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40306     } catch (std::out_of_range& e) {
40307       {
40308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40309       };
40310     } catch (std::exception& e) {
40311       {
40312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40313       };
40314     } catch (...) {
40315       {
40316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40317       };
40318     }
40319   }
40320 }
40321
40322
40323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40324   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40325   Dali::Actor arg2 ;
40326   Dali::Path arg3 ;
40327   Dali::Vector3 *arg4 = 0 ;
40328   Dali::AlphaFunction arg5 ;
40329   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40330   Dali::Actor *argp2 ;
40331   Dali::Path *argp3 ;
40332   Dali::AlphaFunction *argp5 ;
40333   Dali::TimePeriod *argp6 ;
40334
40335   arg1 = (Dali::Animation *)jarg1;
40336   argp2 = (Dali::Actor *)jarg2;
40337   if (!argp2) {
40338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40339     return ;
40340   }
40341   arg2 = *argp2;
40342   argp3 = (Dali::Path *)jarg3;
40343   if (!argp3) {
40344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40345     return ;
40346   }
40347   arg3 = *argp3;
40348   arg4 = (Dali::Vector3 *)jarg4;
40349   if (!arg4) {
40350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40351     return ;
40352   }
40353   argp5 = (Dali::AlphaFunction *)jarg5;
40354   if (!argp5) {
40355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40356     return ;
40357   }
40358   arg5 = *argp5;
40359   argp6 = (Dali::TimePeriod *)jarg6;
40360   if (!argp6) {
40361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40362     return ;
40363   }
40364   arg6 = *argp6;
40365   {
40366     try {
40367       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40368     } catch (std::out_of_range& e) {
40369       {
40370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40371       };
40372     } catch (std::exception& e) {
40373       {
40374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40375       };
40376     } catch (...) {
40377       {
40378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40379       };
40380     }
40381   }
40382 }
40383
40384
40385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40386   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40387   Dali::Actor arg2 ;
40388   float arg3 ;
40389   Dali::Actor *argp2 ;
40390
40391   arg1 = (Dali::Animation *)jarg1;
40392   argp2 = (Dali::Actor *)jarg2;
40393   if (!argp2) {
40394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40395     return ;
40396   }
40397   arg2 = *argp2;
40398   arg3 = (float)jarg3;
40399   {
40400     try {
40401       (arg1)->Show(arg2,arg3);
40402     } catch (std::out_of_range& e) {
40403       {
40404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40405       };
40406     } catch (std::exception& e) {
40407       {
40408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40409       };
40410     } catch (...) {
40411       {
40412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40413       };
40414     }
40415   }
40416 }
40417
40418
40419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40420   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40421   Dali::Actor arg2 ;
40422   float arg3 ;
40423   Dali::Actor *argp2 ;
40424
40425   arg1 = (Dali::Animation *)jarg1;
40426   argp2 = (Dali::Actor *)jarg2;
40427   if (!argp2) {
40428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40429     return ;
40430   }
40431   arg2 = *argp2;
40432   arg3 = (float)jarg3;
40433   {
40434     try {
40435       (arg1)->Hide(arg2,arg3);
40436     } catch (std::out_of_range& e) {
40437       {
40438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40439       };
40440     } catch (std::exception& e) {
40441       {
40442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40443       };
40444     } catch (...) {
40445       {
40446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40447       };
40448     }
40449   }
40450 }
40451
40452
40453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40454   int jresult ;
40455   int result;
40456
40457   result = (int)Dali::LinearConstrainer::Property::VALUE;
40458   jresult = (int)result;
40459   return jresult;
40460 }
40461
40462
40463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40464   int jresult ;
40465   int result;
40466
40467   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40468   jresult = (int)result;
40469   return jresult;
40470 }
40471
40472
40473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40474   void * jresult ;
40475   Dali::LinearConstrainer::Property *result = 0 ;
40476
40477   {
40478     try {
40479       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40480     } catch (std::out_of_range& e) {
40481       {
40482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40483       };
40484     } catch (std::exception& e) {
40485       {
40486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40487       };
40488     } catch (...) {
40489       {
40490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40491       };
40492     }
40493   }
40494   jresult = (void *)result;
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40500   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40501
40502   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40503   {
40504     try {
40505       delete arg1;
40506     } catch (std::out_of_range& e) {
40507       {
40508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40509       };
40510     } catch (std::exception& e) {
40511       {
40512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40513       };
40514     } catch (...) {
40515       {
40516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40517       };
40518     }
40519   }
40520 }
40521
40522
40523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40524   void * jresult ;
40525   Dali::LinearConstrainer result;
40526
40527   {
40528     try {
40529       result = Dali::LinearConstrainer::New();
40530     } catch (std::out_of_range& e) {
40531       {
40532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40533       };
40534     } catch (std::exception& e) {
40535       {
40536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40537       };
40538     } catch (...) {
40539       {
40540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40541       };
40542     }
40543   }
40544   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40545   return jresult;
40546 }
40547
40548
40549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40550   void * jresult ;
40551   Dali::BaseHandle arg1 ;
40552   Dali::BaseHandle *argp1 ;
40553   Dali::LinearConstrainer result;
40554
40555   argp1 = (Dali::BaseHandle *)jarg1;
40556   if (!argp1) {
40557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40558     return 0;
40559   }
40560   arg1 = *argp1;
40561   {
40562     try {
40563       result = Dali::LinearConstrainer::DownCast(arg1);
40564     } catch (std::out_of_range& e) {
40565       {
40566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40567       };
40568     } catch (std::exception& e) {
40569       {
40570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40571       };
40572     } catch (...) {
40573       {
40574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40575       };
40576     }
40577   }
40578   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40579   return jresult;
40580 }
40581
40582
40583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40584   void * jresult ;
40585   Dali::LinearConstrainer *result = 0 ;
40586
40587   {
40588     try {
40589       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40590     } catch (std::out_of_range& e) {
40591       {
40592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40593       };
40594     } catch (std::exception& e) {
40595       {
40596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40597       };
40598     } catch (...) {
40599       {
40600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40601       };
40602     }
40603   }
40604   jresult = (void *)result;
40605   return jresult;
40606 }
40607
40608
40609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40610   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40611
40612   arg1 = (Dali::LinearConstrainer *)jarg1;
40613   {
40614     try {
40615       delete arg1;
40616     } catch (std::out_of_range& e) {
40617       {
40618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40619       };
40620     } catch (std::exception& e) {
40621       {
40622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40623       };
40624     } catch (...) {
40625       {
40626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40627       };
40628     }
40629   }
40630 }
40631
40632
40633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40634   void * jresult ;
40635   Dali::LinearConstrainer *arg1 = 0 ;
40636   Dali::LinearConstrainer *result = 0 ;
40637
40638   arg1 = (Dali::LinearConstrainer *)jarg1;
40639   if (!arg1) {
40640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40641     return 0;
40642   }
40643   {
40644     try {
40645       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40646     } catch (std::out_of_range& e) {
40647       {
40648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40649       };
40650     } catch (std::exception& e) {
40651       {
40652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40653       };
40654     } catch (...) {
40655       {
40656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40657       };
40658     }
40659   }
40660   jresult = (void *)result;
40661   return jresult;
40662 }
40663
40664
40665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40666   void * jresult ;
40667   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40668   Dali::LinearConstrainer *arg2 = 0 ;
40669   Dali::LinearConstrainer *result = 0 ;
40670
40671   arg1 = (Dali::LinearConstrainer *)jarg1;
40672   arg2 = (Dali::LinearConstrainer *)jarg2;
40673   if (!arg2) {
40674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40675     return 0;
40676   }
40677   {
40678     try {
40679       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40680     } catch (std::out_of_range& e) {
40681       {
40682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40683       };
40684     } catch (std::exception& e) {
40685       {
40686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40687       };
40688     } catch (...) {
40689       {
40690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40691       };
40692     }
40693   }
40694   jresult = (void *)result;
40695   return jresult;
40696 }
40697
40698
40699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40700   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40701   SwigValueWrapper< Dali::Property > arg2 ;
40702   SwigValueWrapper< Dali::Property > arg3 ;
40703   Dali::Vector2 *arg4 = 0 ;
40704   Dali::Vector2 *arg5 = 0 ;
40705   Dali::Property *argp2 ;
40706   Dali::Property *argp3 ;
40707
40708   arg1 = (Dali::LinearConstrainer *)jarg1;
40709   argp2 = (Dali::Property *)jarg2;
40710   if (!argp2) {
40711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40712     return ;
40713   }
40714   arg2 = *argp2;
40715   argp3 = (Dali::Property *)jarg3;
40716   if (!argp3) {
40717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40718     return ;
40719   }
40720   arg3 = *argp3;
40721   arg4 = (Dali::Vector2 *)jarg4;
40722   if (!arg4) {
40723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40724     return ;
40725   }
40726   arg5 = (Dali::Vector2 *)jarg5;
40727   if (!arg5) {
40728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40729     return ;
40730   }
40731   {
40732     try {
40733       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40734     } catch (std::out_of_range& e) {
40735       {
40736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40737       };
40738     } catch (std::exception& e) {
40739       {
40740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40741       };
40742     } catch (...) {
40743       {
40744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40745       };
40746     }
40747   }
40748 }
40749
40750
40751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40752   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40753   SwigValueWrapper< Dali::Property > arg2 ;
40754   SwigValueWrapper< Dali::Property > arg3 ;
40755   Dali::Vector2 *arg4 = 0 ;
40756   Dali::Property *argp2 ;
40757   Dali::Property *argp3 ;
40758
40759   arg1 = (Dali::LinearConstrainer *)jarg1;
40760   argp2 = (Dali::Property *)jarg2;
40761   if (!argp2) {
40762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40763     return ;
40764   }
40765   arg2 = *argp2;
40766   argp3 = (Dali::Property *)jarg3;
40767   if (!argp3) {
40768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40769     return ;
40770   }
40771   arg3 = *argp3;
40772   arg4 = (Dali::Vector2 *)jarg4;
40773   if (!arg4) {
40774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40775     return ;
40776   }
40777   {
40778     try {
40779       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40780     } catch (std::out_of_range& e) {
40781       {
40782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40783       };
40784     } catch (std::exception& e) {
40785       {
40786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40787       };
40788     } catch (...) {
40789       {
40790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40791       };
40792     }
40793   }
40794 }
40795
40796
40797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40798   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40799   Dali::Handle *arg2 = 0 ;
40800
40801   arg1 = (Dali::LinearConstrainer *)jarg1;
40802   arg2 = (Dali::Handle *)jarg2;
40803   if (!arg2) {
40804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40805     return ;
40806   }
40807   {
40808     try {
40809       (arg1)->Remove(*arg2);
40810     } catch (std::out_of_range& e) {
40811       {
40812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40813       };
40814     } catch (std::exception& e) {
40815       {
40816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40817       };
40818     } catch (...) {
40819       {
40820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40821       };
40822     }
40823   }
40824 }
40825
40826
40827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40828   int jresult ;
40829   int result;
40830
40831   result = (int)Dali::PathConstrainer::Property::FORWARD;
40832   jresult = (int)result;
40833   return jresult;
40834 }
40835
40836
40837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40838   int jresult ;
40839   int result;
40840
40841   result = (int)Dali::PathConstrainer::Property::POINTS;
40842   jresult = (int)result;
40843   return jresult;
40844 }
40845
40846
40847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40848   int jresult ;
40849   int result;
40850
40851   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40852   jresult = (int)result;
40853   return jresult;
40854 }
40855
40856
40857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40858   void * jresult ;
40859   Dali::PathConstrainer::Property *result = 0 ;
40860
40861   {
40862     try {
40863       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40864     } catch (std::out_of_range& e) {
40865       {
40866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40867       };
40868     } catch (std::exception& e) {
40869       {
40870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40871       };
40872     } catch (...) {
40873       {
40874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40875       };
40876     }
40877   }
40878   jresult = (void *)result;
40879   return jresult;
40880 }
40881
40882
40883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40884   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40885
40886   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40887   {
40888     try {
40889       delete arg1;
40890     } catch (std::out_of_range& e) {
40891       {
40892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40893       };
40894     } catch (std::exception& e) {
40895       {
40896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40897       };
40898     } catch (...) {
40899       {
40900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40901       };
40902     }
40903   }
40904 }
40905
40906
40907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40908   void * jresult ;
40909   Dali::PathConstrainer result;
40910
40911   {
40912     try {
40913       result = Dali::PathConstrainer::New();
40914     } catch (std::out_of_range& e) {
40915       {
40916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40917       };
40918     } catch (std::exception& e) {
40919       {
40920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40921       };
40922     } catch (...) {
40923       {
40924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40925       };
40926     }
40927   }
40928   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40929   return jresult;
40930 }
40931
40932
40933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40934   void * jresult ;
40935   Dali::BaseHandle arg1 ;
40936   Dali::BaseHandle *argp1 ;
40937   Dali::PathConstrainer result;
40938
40939   argp1 = (Dali::BaseHandle *)jarg1;
40940   if (!argp1) {
40941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40942     return 0;
40943   }
40944   arg1 = *argp1;
40945   {
40946     try {
40947       result = Dali::PathConstrainer::DownCast(arg1);
40948     } catch (std::out_of_range& e) {
40949       {
40950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40951       };
40952     } catch (std::exception& e) {
40953       {
40954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40955       };
40956     } catch (...) {
40957       {
40958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40959       };
40960     }
40961   }
40962   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40963   return jresult;
40964 }
40965
40966
40967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40968   void * jresult ;
40969   Dali::PathConstrainer *result = 0 ;
40970
40971   {
40972     try {
40973       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40974     } catch (std::out_of_range& e) {
40975       {
40976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40977       };
40978     } catch (std::exception& e) {
40979       {
40980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40981       };
40982     } catch (...) {
40983       {
40984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40985       };
40986     }
40987   }
40988   jresult = (void *)result;
40989   return jresult;
40990 }
40991
40992
40993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40994   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40995
40996   arg1 = (Dali::PathConstrainer *)jarg1;
40997   {
40998     try {
40999       delete arg1;
41000     } catch (std::out_of_range& e) {
41001       {
41002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41003       };
41004     } catch (std::exception& e) {
41005       {
41006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41007       };
41008     } catch (...) {
41009       {
41010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41011       };
41012     }
41013   }
41014 }
41015
41016
41017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41018   void * jresult ;
41019   Dali::PathConstrainer *arg1 = 0 ;
41020   Dali::PathConstrainer *result = 0 ;
41021
41022   arg1 = (Dali::PathConstrainer *)jarg1;
41023   if (!arg1) {
41024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41025     return 0;
41026   }
41027   {
41028     try {
41029       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41030     } catch (std::out_of_range& e) {
41031       {
41032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41033       };
41034     } catch (std::exception& e) {
41035       {
41036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41037       };
41038     } catch (...) {
41039       {
41040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41041       };
41042     }
41043   }
41044   jresult = (void *)result;
41045   return jresult;
41046 }
41047
41048
41049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41050   void * jresult ;
41051   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41052   Dali::PathConstrainer *arg2 = 0 ;
41053   Dali::PathConstrainer *result = 0 ;
41054
41055   arg1 = (Dali::PathConstrainer *)jarg1;
41056   arg2 = (Dali::PathConstrainer *)jarg2;
41057   if (!arg2) {
41058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41059     return 0;
41060   }
41061   {
41062     try {
41063       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41064     } catch (std::out_of_range& e) {
41065       {
41066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41067       };
41068     } catch (std::exception& e) {
41069       {
41070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41071       };
41072     } catch (...) {
41073       {
41074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41075       };
41076     }
41077   }
41078   jresult = (void *)result;
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41084   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41085   SwigValueWrapper< Dali::Property > arg2 ;
41086   SwigValueWrapper< Dali::Property > arg3 ;
41087   Dali::Vector2 *arg4 = 0 ;
41088   Dali::Vector2 *arg5 = 0 ;
41089   Dali::Property *argp2 ;
41090   Dali::Property *argp3 ;
41091
41092   arg1 = (Dali::PathConstrainer *)jarg1;
41093   argp2 = (Dali::Property *)jarg2;
41094   if (!argp2) {
41095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41096     return ;
41097   }
41098   arg2 = *argp2;
41099   argp3 = (Dali::Property *)jarg3;
41100   if (!argp3) {
41101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41102     return ;
41103   }
41104   arg3 = *argp3;
41105   arg4 = (Dali::Vector2 *)jarg4;
41106   if (!arg4) {
41107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41108     return ;
41109   }
41110   arg5 = (Dali::Vector2 *)jarg5;
41111   if (!arg5) {
41112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41113     return ;
41114   }
41115   {
41116     try {
41117       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41118     } catch (std::out_of_range& e) {
41119       {
41120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41121       };
41122     } catch (std::exception& e) {
41123       {
41124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41125       };
41126     } catch (...) {
41127       {
41128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41129       };
41130     }
41131   }
41132 }
41133
41134
41135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41136   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41137   SwigValueWrapper< Dali::Property > arg2 ;
41138   SwigValueWrapper< Dali::Property > arg3 ;
41139   Dali::Vector2 *arg4 = 0 ;
41140   Dali::Property *argp2 ;
41141   Dali::Property *argp3 ;
41142
41143   arg1 = (Dali::PathConstrainer *)jarg1;
41144   argp2 = (Dali::Property *)jarg2;
41145   if (!argp2) {
41146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41147     return ;
41148   }
41149   arg2 = *argp2;
41150   argp3 = (Dali::Property *)jarg3;
41151   if (!argp3) {
41152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41153     return ;
41154   }
41155   arg3 = *argp3;
41156   arg4 = (Dali::Vector2 *)jarg4;
41157   if (!arg4) {
41158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41159     return ;
41160   }
41161   {
41162     try {
41163       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41164     } catch (std::out_of_range& e) {
41165       {
41166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41167       };
41168     } catch (std::exception& e) {
41169       {
41170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41171       };
41172     } catch (...) {
41173       {
41174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41175       };
41176     }
41177   }
41178 }
41179
41180
41181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41182   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41183   Dali::Handle *arg2 = 0 ;
41184
41185   arg1 = (Dali::PathConstrainer *)jarg1;
41186   arg2 = (Dali::Handle *)jarg2;
41187   if (!arg2) {
41188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41189     return ;
41190   }
41191   {
41192     try {
41193       (arg1)->Remove(*arg2);
41194     } catch (std::out_of_range& e) {
41195       {
41196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41197       };
41198     } catch (std::exception& e) {
41199       {
41200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41205       };
41206     }
41207   }
41208 }
41209
41210
41211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41212   int jresult ;
41213   Dali::FittingMode::Type result;
41214
41215   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41216   jresult = (int)result;
41217   return jresult;
41218 }
41219
41220
41221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41222   int jresult ;
41223   Dali::SamplingMode::Type result;
41224
41225   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41226   jresult = (int)result;
41227   return jresult;
41228 }
41229
41230
41231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41232   void * jresult ;
41233   Dali::BufferImage *result = 0 ;
41234
41235   {
41236     try {
41237       result = (Dali::BufferImage *)new Dali::BufferImage();
41238     } catch (std::out_of_range& e) {
41239       {
41240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41241       };
41242     } catch (std::exception& e) {
41243       {
41244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41245       };
41246     } catch (...) {
41247       {
41248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41249       };
41250     }
41251   }
41252   jresult = (void *)result;
41253   return jresult;
41254 }
41255
41256
41257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41258   void * jresult ;
41259   unsigned int arg1 ;
41260   unsigned int arg2 ;
41261   Dali::Pixel::Format arg3 ;
41262   Dali::BufferImage result;
41263
41264   arg1 = (unsigned int)jarg1;
41265   arg2 = (unsigned int)jarg2;
41266   arg3 = (Dali::Pixel::Format)jarg3;
41267   {
41268     try {
41269       result = Dali::BufferImage::New(arg1,arg2,arg3);
41270     } catch (std::out_of_range& e) {
41271       {
41272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41273       };
41274     } catch (std::exception& e) {
41275       {
41276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41277       };
41278     } catch (...) {
41279       {
41280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41281       };
41282     }
41283   }
41284   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41285   return jresult;
41286 }
41287
41288
41289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41290   void * jresult ;
41291   unsigned int arg1 ;
41292   unsigned int arg2 ;
41293   Dali::BufferImage result;
41294
41295   arg1 = (unsigned int)jarg1;
41296   arg2 = (unsigned int)jarg2;
41297   {
41298     try {
41299       result = Dali::BufferImage::New(arg1,arg2);
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (...) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41311       };
41312     }
41313   }
41314   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41320   void * jresult ;
41321   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41322   unsigned int arg2 ;
41323   unsigned int arg3 ;
41324   Dali::Pixel::Format arg4 ;
41325   unsigned int arg5 ;
41326   Dali::BufferImage result;
41327
41328   arg1 = jarg1;
41329   arg2 = (unsigned int)jarg2;
41330   arg3 = (unsigned int)jarg3;
41331   arg4 = (Dali::Pixel::Format)jarg4;
41332   arg5 = (unsigned int)jarg5;
41333   {
41334     try {
41335       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41336     } catch (std::out_of_range& e) {
41337       {
41338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41339       };
41340     } catch (std::exception& e) {
41341       {
41342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (...) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41347       };
41348     }
41349   }
41350   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41351
41352
41353   return jresult;
41354 }
41355
41356
41357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41358   void * jresult ;
41359   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41360   unsigned int arg2 ;
41361   unsigned int arg3 ;
41362   Dali::Pixel::Format arg4 ;
41363   Dali::BufferImage result;
41364
41365   arg1 = jarg1;
41366   arg2 = (unsigned int)jarg2;
41367   arg3 = (unsigned int)jarg3;
41368   arg4 = (Dali::Pixel::Format)jarg4;
41369   {
41370     try {
41371       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41372     } catch (std::out_of_range& e) {
41373       {
41374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41375       };
41376     } catch (std::exception& e) {
41377       {
41378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41379       };
41380     } catch (...) {
41381       {
41382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41383       };
41384     }
41385   }
41386   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41387
41388
41389   return jresult;
41390 }
41391
41392
41393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41394   void * jresult ;
41395   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41396   unsigned int arg2 ;
41397   unsigned int arg3 ;
41398   Dali::BufferImage result;
41399
41400   arg1 = jarg1;
41401   arg2 = (unsigned int)jarg2;
41402   arg3 = (unsigned int)jarg3;
41403   {
41404     try {
41405       result = Dali::BufferImage::New(arg1,arg2,arg3);
41406     } catch (std::out_of_range& e) {
41407       {
41408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41409       };
41410     } catch (std::exception& e) {
41411       {
41412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41413       };
41414     } catch (...) {
41415       {
41416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41417       };
41418     }
41419   }
41420   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41421
41422
41423   return jresult;
41424 }
41425
41426
41427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41428   void * jresult ;
41429   Dali::BaseHandle arg1 ;
41430   Dali::BaseHandle *argp1 ;
41431   Dali::BufferImage result;
41432
41433   argp1 = (Dali::BaseHandle *)jarg1;
41434   if (!argp1) {
41435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41436     return 0;
41437   }
41438   arg1 = *argp1;
41439   {
41440     try {
41441       result = Dali::BufferImage::DownCast(arg1);
41442     } catch (std::out_of_range& e) {
41443       {
41444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41445       };
41446     } catch (std::exception& e) {
41447       {
41448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41449       };
41450     } catch (...) {
41451       {
41452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41453       };
41454     }
41455   }
41456   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41457   return jresult;
41458 }
41459
41460
41461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41462   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41463
41464   arg1 = (Dali::BufferImage *)jarg1;
41465   {
41466     try {
41467       delete arg1;
41468     } catch (std::out_of_range& e) {
41469       {
41470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41471       };
41472     } catch (std::exception& e) {
41473       {
41474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41475       };
41476     } catch (...) {
41477       {
41478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41479       };
41480     }
41481   }
41482 }
41483
41484
41485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41486   void * jresult ;
41487   Dali::BufferImage *arg1 = 0 ;
41488   Dali::BufferImage *result = 0 ;
41489
41490   arg1 = (Dali::BufferImage *)jarg1;
41491   if (!arg1) {
41492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41493     return 0;
41494   }
41495   {
41496     try {
41497       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41498     } catch (std::out_of_range& e) {
41499       {
41500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41501       };
41502     } catch (std::exception& e) {
41503       {
41504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41505       };
41506     } catch (...) {
41507       {
41508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41509       };
41510     }
41511   }
41512   jresult = (void *)result;
41513   return jresult;
41514 }
41515
41516
41517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41518   void * jresult ;
41519   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41520   Dali::BufferImage *arg2 = 0 ;
41521   Dali::BufferImage *result = 0 ;
41522
41523   arg1 = (Dali::BufferImage *)jarg1;
41524   arg2 = (Dali::BufferImage *)jarg2;
41525   if (!arg2) {
41526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41527     return 0;
41528   }
41529   {
41530     try {
41531       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41532     } catch (std::out_of_range& e) {
41533       {
41534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41535       };
41536     } catch (std::exception& e) {
41537       {
41538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41539       };
41540     } catch (...) {
41541       {
41542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41543       };
41544     }
41545   }
41546   jresult = (void *)result;
41547   return jresult;
41548 }
41549
41550
41551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41552   void * jresult ;
41553   Dali::BufferImage result;
41554
41555   {
41556     try {
41557       result = Dali::BufferImage::WHITE();
41558     } catch (std::out_of_range& e) {
41559       {
41560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41561       };
41562     } catch (std::exception& e) {
41563       {
41564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41565       };
41566     } catch (...) {
41567       {
41568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41569       };
41570     }
41571   }
41572   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41573   return jresult;
41574 }
41575
41576
41577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41578   void * jresult ;
41579   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41580   Dali::PixelBuffer *result = 0 ;
41581
41582   arg1 = (Dali::BufferImage *)jarg1;
41583   {
41584     try {
41585       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41586     } catch (std::out_of_range& e) {
41587       {
41588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41589       };
41590     } catch (std::exception& e) {
41591       {
41592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41593       };
41594     } catch (...) {
41595       {
41596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41597       };
41598     }
41599   }
41600   jresult = (void *)result;
41601   return jresult;
41602 }
41603
41604
41605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41606   unsigned int jresult ;
41607   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41608   unsigned int result;
41609
41610   arg1 = (Dali::BufferImage *)jarg1;
41611   {
41612     try {
41613       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41614     } catch (std::out_of_range& e) {
41615       {
41616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41617       };
41618     } catch (std::exception& e) {
41619       {
41620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41621       };
41622     } catch (...) {
41623       {
41624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41625       };
41626     }
41627   }
41628   jresult = result;
41629   return jresult;
41630 }
41631
41632
41633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41634   unsigned int jresult ;
41635   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41636   unsigned int result;
41637
41638   arg1 = (Dali::BufferImage *)jarg1;
41639   {
41640     try {
41641       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41642     } catch (std::out_of_range& e) {
41643       {
41644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41645       };
41646     } catch (std::exception& e) {
41647       {
41648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41649       };
41650     } catch (...) {
41651       {
41652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41653       };
41654     }
41655   }
41656   jresult = result;
41657   return jresult;
41658 }
41659
41660
41661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41662   int jresult ;
41663   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41664   Dali::Pixel::Format result;
41665
41666   arg1 = (Dali::BufferImage *)jarg1;
41667   {
41668     try {
41669       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41670     } catch (std::out_of_range& e) {
41671       {
41672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41673       };
41674     } catch (std::exception& e) {
41675       {
41676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41677       };
41678     } catch (...) {
41679       {
41680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41681       };
41682     }
41683   }
41684   jresult = (int)result;
41685   return jresult;
41686 }
41687
41688
41689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41691
41692   arg1 = (Dali::BufferImage *)jarg1;
41693   {
41694     try {
41695       (arg1)->Update();
41696     } catch (std::out_of_range& e) {
41697       {
41698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41699       };
41700     } catch (std::exception& e) {
41701       {
41702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41703       };
41704     } catch (...) {
41705       {
41706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41707       };
41708     }
41709   }
41710 }
41711
41712
41713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41714   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41715   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41716   Dali::RectArea *argp2 ;
41717
41718   arg1 = (Dali::BufferImage *)jarg1;
41719   argp2 = (Dali::RectArea *)jarg2;
41720   if (!argp2) {
41721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41722     return ;
41723   }
41724   arg2 = *argp2;
41725   {
41726     try {
41727       (arg1)->Update(arg2);
41728     } catch (std::out_of_range& e) {
41729       {
41730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41731       };
41732     } catch (std::exception& e) {
41733       {
41734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41735       };
41736     } catch (...) {
41737       {
41738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41739       };
41740     }
41741   }
41742 }
41743
41744
41745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41746   unsigned int jresult ;
41747   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41748   bool result;
41749
41750   arg1 = (Dali::BufferImage *)jarg1;
41751   {
41752     try {
41753       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41754     } catch (std::out_of_range& e) {
41755       {
41756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41757       };
41758     } catch (std::exception& e) {
41759       {
41760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41761       };
41762     } catch (...) {
41763       {
41764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41765       };
41766     }
41767   }
41768   jresult = result;
41769   return jresult;
41770 }
41771
41772
41773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41774   void * jresult ;
41775   Dali::EncodedBufferImage *result = 0 ;
41776
41777   {
41778     try {
41779       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41780     } catch (std::out_of_range& e) {
41781       {
41782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41783       };
41784     } catch (std::exception& e) {
41785       {
41786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41787       };
41788     } catch (...) {
41789       {
41790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41791       };
41792     }
41793   }
41794   jresult = (void *)result;
41795   return jresult;
41796 }
41797
41798
41799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41800   void * jresult ;
41801   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41802   std::size_t arg2 ;
41803   Dali::EncodedBufferImage result;
41804
41805   arg1 = (uint8_t *)jarg1;
41806   arg2 = (std::size_t)jarg2;
41807   {
41808     try {
41809       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41810     } catch (std::out_of_range& e) {
41811       {
41812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41813       };
41814     } catch (std::exception& e) {
41815       {
41816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (...) {
41819       {
41820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41821       };
41822     }
41823   }
41824   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41825   return jresult;
41826 }
41827
41828
41829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41830   void * jresult ;
41831   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41832   std::size_t arg2 ;
41833   Dali::ImageDimensions arg3 ;
41834   Dali::FittingMode::Type arg4 ;
41835   Dali::SamplingMode::Type arg5 ;
41836   bool arg6 ;
41837   Dali::ImageDimensions *argp3 ;
41838   Dali::EncodedBufferImage result;
41839
41840   arg1 = (uint8_t *)jarg1;
41841   arg2 = (std::size_t)jarg2;
41842   argp3 = (Dali::ImageDimensions *)jarg3;
41843   if (!argp3) {
41844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41845     return 0;
41846   }
41847   arg3 = *argp3;
41848   arg4 = (Dali::FittingMode::Type)jarg4;
41849   arg5 = (Dali::SamplingMode::Type)jarg5;
41850   arg6 = jarg6 ? true : false;
41851   {
41852     try {
41853       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41854     } catch (std::out_of_range& e) {
41855       {
41856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41857       };
41858     } catch (std::exception& e) {
41859       {
41860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41861       };
41862     } catch (...) {
41863       {
41864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41865       };
41866     }
41867   }
41868   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41869   return jresult;
41870 }
41871
41872
41873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41874   void * jresult ;
41875   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41876   std::size_t arg2 ;
41877   Dali::ImageDimensions arg3 ;
41878   Dali::FittingMode::Type arg4 ;
41879   Dali::SamplingMode::Type arg5 ;
41880   Dali::ImageDimensions *argp3 ;
41881   Dali::EncodedBufferImage result;
41882
41883   arg1 = (uint8_t *)jarg1;
41884   arg2 = (std::size_t)jarg2;
41885   argp3 = (Dali::ImageDimensions *)jarg3;
41886   if (!argp3) {
41887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41888     return 0;
41889   }
41890   arg3 = *argp3;
41891   arg4 = (Dali::FittingMode::Type)jarg4;
41892   arg5 = (Dali::SamplingMode::Type)jarg5;
41893   {
41894     try {
41895       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41896     } catch (std::out_of_range& e) {
41897       {
41898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41899       };
41900     } catch (std::exception& e) {
41901       {
41902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41903       };
41904     } catch (...) {
41905       {
41906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41907       };
41908     }
41909   }
41910   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41911   return jresult;
41912 }
41913
41914
41915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41916   void * jresult ;
41917   Dali::BaseHandle arg1 ;
41918   Dali::BaseHandle *argp1 ;
41919   Dali::EncodedBufferImage result;
41920
41921   argp1 = (Dali::BaseHandle *)jarg1;
41922   if (!argp1) {
41923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41924     return 0;
41925   }
41926   arg1 = *argp1;
41927   {
41928     try {
41929       result = Dali::EncodedBufferImage::DownCast(arg1);
41930     } catch (std::out_of_range& e) {
41931       {
41932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (std::exception& e) {
41935       {
41936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (...) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41941       };
41942     }
41943   }
41944   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41945   return jresult;
41946 }
41947
41948
41949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41950   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41951
41952   arg1 = (Dali::EncodedBufferImage *)jarg1;
41953   {
41954     try {
41955       delete arg1;
41956     } catch (std::out_of_range& e) {
41957       {
41958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41959       };
41960     } catch (std::exception& e) {
41961       {
41962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41963       };
41964     } catch (...) {
41965       {
41966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41967       };
41968     }
41969   }
41970 }
41971
41972
41973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41974   void * jresult ;
41975   Dali::EncodedBufferImage *arg1 = 0 ;
41976   Dali::EncodedBufferImage *result = 0 ;
41977
41978   arg1 = (Dali::EncodedBufferImage *)jarg1;
41979   if (!arg1) {
41980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41981     return 0;
41982   }
41983   {
41984     try {
41985       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41986     } catch (std::out_of_range& e) {
41987       {
41988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41989       };
41990     } catch (std::exception& e) {
41991       {
41992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41993       };
41994     } catch (...) {
41995       {
41996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41997       };
41998     }
41999   }
42000   jresult = (void *)result;
42001   return jresult;
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42006   void * jresult ;
42007   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42008   Dali::EncodedBufferImage *arg2 = 0 ;
42009   Dali::EncodedBufferImage *result = 0 ;
42010
42011   arg1 = (Dali::EncodedBufferImage *)jarg1;
42012   arg2 = (Dali::EncodedBufferImage *)jarg2;
42013   if (!arg2) {
42014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42015     return 0;
42016   }
42017   {
42018     try {
42019       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42020     } catch (std::out_of_range& e) {
42021       {
42022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42023       };
42024     } catch (std::exception& e) {
42025       {
42026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42027       };
42028     } catch (...) {
42029       {
42030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42031       };
42032     }
42033   }
42034   jresult = (void *)result;
42035   return jresult;
42036 }
42037
42038
42039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42040   void * jresult ;
42041   Dali::NativeImage *result = 0 ;
42042
42043   {
42044     try {
42045       result = (Dali::NativeImage *)new Dali::NativeImage();
42046     } catch (std::out_of_range& e) {
42047       {
42048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42049       };
42050     } catch (std::exception& e) {
42051       {
42052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42053       };
42054     } catch (...) {
42055       {
42056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42057       };
42058     }
42059   }
42060   jresult = (void *)result;
42061   return jresult;
42062 }
42063
42064
42065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42066   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42067
42068   arg1 = (Dali::NativeImage *)jarg1;
42069   {
42070     try {
42071       delete arg1;
42072     } catch (std::out_of_range& e) {
42073       {
42074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42075       };
42076     } catch (std::exception& e) {
42077       {
42078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42079       };
42080     } catch (...) {
42081       {
42082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42083       };
42084     }
42085   }
42086 }
42087
42088
42089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42090   void * jresult ;
42091   Dali::NativeImage *arg1 = 0 ;
42092   Dali::NativeImage *result = 0 ;
42093
42094   arg1 = (Dali::NativeImage *)jarg1;
42095   if (!arg1) {
42096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42097     return 0;
42098   }
42099   {
42100     try {
42101       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42102     } catch (std::out_of_range& e) {
42103       {
42104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42105       };
42106     } catch (std::exception& e) {
42107       {
42108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42109       };
42110     } catch (...) {
42111       {
42112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42113       };
42114     }
42115   }
42116   jresult = (void *)result;
42117   return jresult;
42118 }
42119
42120
42121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42122   void * jresult ;
42123   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42124   Dali::NativeImage *arg2 = 0 ;
42125   Dali::NativeImage *result = 0 ;
42126
42127   arg1 = (Dali::NativeImage *)jarg1;
42128   arg2 = (Dali::NativeImage *)jarg2;
42129   if (!arg2) {
42130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42131     return 0;
42132   }
42133   {
42134     try {
42135       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42136     } catch (std::out_of_range& e) {
42137       {
42138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42139       };
42140     } catch (std::exception& e) {
42141       {
42142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42143       };
42144     } catch (...) {
42145       {
42146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42147       };
42148     }
42149   }
42150   jresult = (void *)result;
42151   return jresult;
42152 }
42153
42154
42155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42156   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42157
42158   arg1 = (Dali::NativeImage *)jarg1;
42159   {
42160     try {
42161       (arg1)->CreateGlTexture();
42162     } catch (std::out_of_range& e) {
42163       {
42164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42165       };
42166     } catch (std::exception& e) {
42167       {
42168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42169       };
42170     } catch (...) {
42171       {
42172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42173       };
42174     }
42175   }
42176 }
42177
42178
42179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42180   void * jresult ;
42181   NativeImageInterface *arg1 = 0 ;
42182   Dali::NativeImage result;
42183
42184   arg1 = (NativeImageInterface *)jarg1;
42185   if (!arg1) {
42186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42187     return 0;
42188   }
42189   {
42190     try {
42191       result = Dali::NativeImage::New(*arg1);
42192     } catch (std::out_of_range& e) {
42193       {
42194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42195       };
42196     } catch (std::exception& e) {
42197       {
42198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42199       };
42200     } catch (...) {
42201       {
42202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42203       };
42204     }
42205   }
42206   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42207   return jresult;
42208 }
42209
42210
42211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42212   void * jresult ;
42213   Dali::BaseHandle arg1 ;
42214   Dali::BaseHandle *argp1 ;
42215   Dali::NativeImage result;
42216
42217   argp1 = (Dali::BaseHandle *)jarg1;
42218   if (!argp1) {
42219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42220     return 0;
42221   }
42222   arg1 = *argp1;
42223   {
42224     try {
42225       result = Dali::NativeImage::DownCast(arg1);
42226     } catch (std::out_of_range& e) {
42227       {
42228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42229       };
42230     } catch (std::exception& e) {
42231       {
42232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42233       };
42234     } catch (...) {
42235       {
42236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42237       };
42238     }
42239   }
42240   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42241   return jresult;
42242 }
42243
42244
42245 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42246   char * jresult ;
42247   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42248   char *result = 0 ;
42249
42250   arg1 = (Dali::NativeImage *)jarg1;
42251   {
42252     try {
42253       result = (char *)(arg1)->GetCustomFragmentPreFix();
42254     } catch (std::out_of_range& e) {
42255       {
42256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42257       };
42258     } catch (std::exception& e) {
42259       {
42260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (...) {
42263       {
42264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42265       };
42266     }
42267   }
42268   jresult = SWIG_csharp_string_callback((const char *)result);
42269   return jresult;
42270 }
42271
42272
42273 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42274   char * jresult ;
42275   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42276   char *result = 0 ;
42277
42278   arg1 = (Dali::NativeImage *)jarg1;
42279   {
42280     try {
42281       result = (char *)(arg1)->GetCustomSamplerTypename();
42282     } catch (std::out_of_range& e) {
42283       {
42284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42285       };
42286     } catch (std::exception& e) {
42287       {
42288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42289       };
42290     } catch (...) {
42291       {
42292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42293       };
42294     }
42295   }
42296   jresult = SWIG_csharp_string_callback((const char *)result);
42297   return jresult;
42298 }
42299
42300
42301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42302   unsigned int jresult ;
42303   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42304   bool result;
42305
42306   arg1 = (Dali::NativeImageInterface *)jarg1;
42307   {
42308     try {
42309       result = (bool)(arg1)->GlExtensionCreate();
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (...) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42321       };
42322     }
42323   }
42324   jresult = result;
42325   return jresult;
42326 }
42327
42328
42329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42330   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42331
42332   arg1 = (Dali::NativeImageInterface *)jarg1;
42333   {
42334     try {
42335       (arg1)->GlExtensionDestroy();
42336     } catch (std::out_of_range& e) {
42337       {
42338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42339       };
42340     } catch (std::exception& e) {
42341       {
42342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42343       };
42344     } catch (...) {
42345       {
42346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42347       };
42348     }
42349   }
42350 }
42351
42352
42353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42354   unsigned int jresult ;
42355   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42356   unsigned int result;
42357
42358   arg1 = (Dali::NativeImageInterface *)jarg1;
42359   {
42360     try {
42361       result = (unsigned int)(arg1)->TargetTexture();
42362     } catch (std::out_of_range& e) {
42363       {
42364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42365       };
42366     } catch (std::exception& e) {
42367       {
42368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42369       };
42370     } catch (...) {
42371       {
42372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42373       };
42374     }
42375   }
42376   jresult = result;
42377   return jresult;
42378 }
42379
42380
42381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42382   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42383
42384   arg1 = (Dali::NativeImageInterface *)jarg1;
42385   {
42386     try {
42387       (arg1)->PrepareTexture();
42388     } catch (std::out_of_range& e) {
42389       {
42390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42391       };
42392     } catch (std::exception& e) {
42393       {
42394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42395       };
42396     } catch (...) {
42397       {
42398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42399       };
42400     }
42401   }
42402 }
42403
42404
42405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42406   unsigned int jresult ;
42407   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42408   unsigned int result;
42409
42410   arg1 = (Dali::NativeImageInterface *)jarg1;
42411   {
42412     try {
42413       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42414     } catch (std::out_of_range& e) {
42415       {
42416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42417       };
42418     } catch (std::exception& e) {
42419       {
42420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42421       };
42422     } catch (...) {
42423       {
42424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42425       };
42426     }
42427   }
42428   jresult = result;
42429   return jresult;
42430 }
42431
42432
42433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42434   unsigned int jresult ;
42435   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42436   unsigned int result;
42437
42438   arg1 = (Dali::NativeImageInterface *)jarg1;
42439   {
42440     try {
42441       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42442     } catch (std::out_of_range& e) {
42443       {
42444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (std::exception& e) {
42447       {
42448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (...) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42453       };
42454     }
42455   }
42456   jresult = result;
42457   return jresult;
42458 }
42459
42460
42461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42462   unsigned int jresult ;
42463   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42464   bool result;
42465
42466   arg1 = (Dali::NativeImageInterface *)jarg1;
42467   {
42468     try {
42469       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42470     } catch (std::out_of_range& e) {
42471       {
42472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42473       };
42474     } catch (std::exception& e) {
42475       {
42476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42477       };
42478     } catch (...) {
42479       {
42480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42481       };
42482     }
42483   }
42484   jresult = result;
42485   return jresult;
42486 }
42487
42488
42489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42490   void * jresult ;
42491   std::string *arg1 = 0 ;
42492   Dali::ImageDimensions result;
42493
42494   if (!jarg1) {
42495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42496     return 0;
42497   }
42498   std::string arg1_str(jarg1);
42499   arg1 = &arg1_str;
42500   {
42501     try {
42502       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42503     } catch (std::out_of_range& e) {
42504       {
42505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42506       };
42507     } catch (std::exception& e) {
42508       {
42509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42510       };
42511     } catch (...) {
42512       {
42513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42514       };
42515     }
42516   }
42517   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42518
42519   //argout typemap for const std::string&
42520
42521   return jresult;
42522 }
42523
42524
42525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42526   void * jresult ;
42527   Dali::ResourceImage *result = 0 ;
42528
42529   {
42530     try {
42531       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42532     } catch (std::out_of_range& e) {
42533       {
42534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42535       };
42536     } catch (std::exception& e) {
42537       {
42538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (...) {
42541       {
42542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42543       };
42544     }
42545   }
42546   jresult = (void *)result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42552   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42553
42554   arg1 = (Dali::ResourceImage *)jarg1;
42555   {
42556     try {
42557       delete arg1;
42558     } catch (std::out_of_range& e) {
42559       {
42560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42561       };
42562     } catch (std::exception& e) {
42563       {
42564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42565       };
42566     } catch (...) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42569       };
42570     }
42571   }
42572 }
42573
42574
42575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42576   void * jresult ;
42577   Dali::ResourceImage *arg1 = 0 ;
42578   Dali::ResourceImage *result = 0 ;
42579
42580   arg1 = (Dali::ResourceImage *)jarg1;
42581   if (!arg1) {
42582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42583     return 0;
42584   }
42585   {
42586     try {
42587       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42588     } catch (std::out_of_range& e) {
42589       {
42590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42591       };
42592     } catch (std::exception& e) {
42593       {
42594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42595       };
42596     } catch (...) {
42597       {
42598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42599       };
42600     }
42601   }
42602   jresult = (void *)result;
42603   return jresult;
42604 }
42605
42606
42607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42608   void * jresult ;
42609   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42610   Dali::ResourceImage *arg2 = 0 ;
42611   Dali::ResourceImage *result = 0 ;
42612
42613   arg1 = (Dali::ResourceImage *)jarg1;
42614   arg2 = (Dali::ResourceImage *)jarg2;
42615   if (!arg2) {
42616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42617     return 0;
42618   }
42619   {
42620     try {
42621       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42622     } catch (std::out_of_range& e) {
42623       {
42624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42625       };
42626     } catch (std::exception& e) {
42627       {
42628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42629       };
42630     } catch (...) {
42631       {
42632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42633       };
42634     }
42635   }
42636   jresult = (void *)result;
42637   return jresult;
42638 }
42639
42640
42641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42642   void * jresult ;
42643   std::string *arg1 = 0 ;
42644   bool arg2 ;
42645   Dali::ResourceImage result;
42646
42647   if (!jarg1) {
42648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42649     return 0;
42650   }
42651   std::string arg1_str(jarg1);
42652   arg1 = &arg1_str;
42653   arg2 = jarg2 ? true : false;
42654   {
42655     try {
42656       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42657     } catch (std::out_of_range& e) {
42658       {
42659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42660       };
42661     } catch (std::exception& e) {
42662       {
42663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42664       };
42665     } catch (...) {
42666       {
42667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42668       };
42669     }
42670   }
42671   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42672
42673   //argout typemap for const std::string&
42674
42675   return jresult;
42676 }
42677
42678
42679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42680   void * jresult ;
42681   std::string *arg1 = 0 ;
42682   Dali::ResourceImage result;
42683
42684   if (!jarg1) {
42685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42686     return 0;
42687   }
42688   std::string arg1_str(jarg1);
42689   arg1 = &arg1_str;
42690   {
42691     try {
42692       result = Dali::ResourceImage::New((std::string const &)*arg1);
42693     } catch (std::out_of_range& e) {
42694       {
42695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42696       };
42697     } catch (std::exception& e) {
42698       {
42699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42700       };
42701     } catch (...) {
42702       {
42703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42704       };
42705     }
42706   }
42707   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42708
42709   //argout typemap for const std::string&
42710
42711   return jresult;
42712 }
42713
42714
42715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42716   void * jresult ;
42717   std::string *arg1 = 0 ;
42718   Dali::ImageDimensions arg2 ;
42719   Dali::FittingMode::Type arg3 ;
42720   Dali::SamplingMode::Type arg4 ;
42721   bool arg5 ;
42722   Dali::ImageDimensions *argp2 ;
42723   Dali::ResourceImage result;
42724
42725   if (!jarg1) {
42726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42727     return 0;
42728   }
42729   std::string arg1_str(jarg1);
42730   arg1 = &arg1_str;
42731   argp2 = (Dali::ImageDimensions *)jarg2;
42732   if (!argp2) {
42733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42734     return 0;
42735   }
42736   arg2 = *argp2;
42737   arg3 = (Dali::FittingMode::Type)jarg3;
42738   arg4 = (Dali::SamplingMode::Type)jarg4;
42739   arg5 = jarg5 ? true : false;
42740   {
42741     try {
42742       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42743     } catch (std::out_of_range& e) {
42744       {
42745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42746       };
42747     } catch (std::exception& e) {
42748       {
42749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42750       };
42751     } catch (...) {
42752       {
42753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42754       };
42755     }
42756   }
42757   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42758
42759   //argout typemap for const std::string&
42760
42761   return jresult;
42762 }
42763
42764
42765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42766   void * jresult ;
42767   std::string *arg1 = 0 ;
42768   Dali::ImageDimensions arg2 ;
42769   Dali::FittingMode::Type arg3 ;
42770   Dali::SamplingMode::Type arg4 ;
42771   Dali::ImageDimensions *argp2 ;
42772   Dali::ResourceImage result;
42773
42774   if (!jarg1) {
42775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42776     return 0;
42777   }
42778   std::string arg1_str(jarg1);
42779   arg1 = &arg1_str;
42780   argp2 = (Dali::ImageDimensions *)jarg2;
42781   if (!argp2) {
42782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42783     return 0;
42784   }
42785   arg2 = *argp2;
42786   arg3 = (Dali::FittingMode::Type)jarg3;
42787   arg4 = (Dali::SamplingMode::Type)jarg4;
42788   {
42789     try {
42790       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42791     } catch (std::out_of_range& e) {
42792       {
42793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42794       };
42795     } catch (std::exception& e) {
42796       {
42797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42798       };
42799     } catch (...) {
42800       {
42801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42802       };
42803     }
42804   }
42805   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42806
42807   //argout typemap for const std::string&
42808
42809   return jresult;
42810 }
42811
42812
42813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42814   void * jresult ;
42815   std::string *arg1 = 0 ;
42816   Dali::ImageDimensions arg2 ;
42817   Dali::FittingMode::Type arg3 ;
42818   Dali::ImageDimensions *argp2 ;
42819   Dali::ResourceImage result;
42820
42821   if (!jarg1) {
42822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42823     return 0;
42824   }
42825   std::string arg1_str(jarg1);
42826   arg1 = &arg1_str;
42827   argp2 = (Dali::ImageDimensions *)jarg2;
42828   if (!argp2) {
42829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42830     return 0;
42831   }
42832   arg2 = *argp2;
42833   arg3 = (Dali::FittingMode::Type)jarg3;
42834   {
42835     try {
42836       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42837     } catch (std::out_of_range& e) {
42838       {
42839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42840       };
42841     } catch (std::exception& e) {
42842       {
42843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42844       };
42845     } catch (...) {
42846       {
42847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42848       };
42849     }
42850   }
42851   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42852
42853   //argout typemap for const std::string&
42854
42855   return jresult;
42856 }
42857
42858
42859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42860   void * jresult ;
42861   std::string *arg1 = 0 ;
42862   Dali::ImageDimensions arg2 ;
42863   Dali::ImageDimensions *argp2 ;
42864   Dali::ResourceImage result;
42865
42866   if (!jarg1) {
42867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42868     return 0;
42869   }
42870   std::string arg1_str(jarg1);
42871   arg1 = &arg1_str;
42872   argp2 = (Dali::ImageDimensions *)jarg2;
42873   if (!argp2) {
42874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42875     return 0;
42876   }
42877   arg2 = *argp2;
42878   {
42879     try {
42880       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42881     } catch (std::out_of_range& e) {
42882       {
42883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (std::exception& e) {
42886       {
42887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (...) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42892       };
42893     }
42894   }
42895   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42896
42897   //argout typemap for const std::string&
42898
42899   return jresult;
42900 }
42901
42902
42903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42904   void * jresult ;
42905   Dali::BaseHandle arg1 ;
42906   Dali::BaseHandle *argp1 ;
42907   Dali::ResourceImage result;
42908
42909   argp1 = (Dali::BaseHandle *)jarg1;
42910   if (!argp1) {
42911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42912     return 0;
42913   }
42914   arg1 = *argp1;
42915   {
42916     try {
42917       result = Dali::ResourceImage::DownCast(arg1);
42918     } catch (std::out_of_range& e) {
42919       {
42920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42921       };
42922     } catch (std::exception& e) {
42923       {
42924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42925       };
42926     } catch (...) {
42927       {
42928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42929       };
42930     }
42931   }
42932   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42933   return jresult;
42934 }
42935
42936
42937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42938   int jresult ;
42939   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42940   Dali::LoadingState result;
42941
42942   arg1 = (Dali::ResourceImage *)jarg1;
42943   {
42944     try {
42945       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42946     } catch (std::out_of_range& e) {
42947       {
42948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42949       };
42950     } catch (std::exception& e) {
42951       {
42952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42953       };
42954     } catch (...) {
42955       {
42956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42957       };
42958     }
42959   }
42960   jresult = (int)result;
42961   return jresult;
42962 }
42963
42964
42965 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42966   char * jresult ;
42967   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42968   std::string result;
42969
42970   arg1 = (Dali::ResourceImage *)jarg1;
42971   {
42972     try {
42973       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42974     } catch (std::out_of_range& e) {
42975       {
42976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42977       };
42978     } catch (std::exception& e) {
42979       {
42980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42981       };
42982     } catch (...) {
42983       {
42984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42985       };
42986     }
42987   }
42988   jresult = SWIG_csharp_string_callback((&result)->c_str());
42989   return jresult;
42990 }
42991
42992
42993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42994   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42995
42996   arg1 = (Dali::ResourceImage *)jarg1;
42997   {
42998     try {
42999       (arg1)->Reload();
43000     } catch (std::out_of_range& e) {
43001       {
43002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43003       };
43004     } catch (std::exception& e) {
43005       {
43006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43007       };
43008     } catch (...) {
43009       {
43010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43011       };
43012     }
43013   }
43014 }
43015
43016
43017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43018   void * jresult ;
43019   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43020   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43021
43022   arg1 = (Dali::ResourceImage *)jarg1;
43023   {
43024     try {
43025       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43026     } catch (std::out_of_range& e) {
43027       {
43028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43029       };
43030     } catch (std::exception& e) {
43031       {
43032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43033       };
43034     } catch (...) {
43035       {
43036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43037       };
43038     }
43039   }
43040   jresult = (void *)result;
43041   return jresult;
43042 }
43043
43044
43045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43046   void * jresult ;
43047   Dali::FrameBufferImage *result = 0 ;
43048
43049   {
43050     try {
43051       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43052     } catch (std::out_of_range& e) {
43053       {
43054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43055       };
43056     } catch (std::exception& e) {
43057       {
43058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (...) {
43061       {
43062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43063       };
43064     }
43065   }
43066   jresult = (void *)result;
43067   return jresult;
43068 }
43069
43070
43071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43072   void * jresult ;
43073   unsigned int arg1 ;
43074   unsigned int arg2 ;
43075   Dali::Pixel::Format arg3 ;
43076   Dali::RenderBuffer::Format arg4 ;
43077   Dali::FrameBufferImage result;
43078
43079   arg1 = (unsigned int)jarg1;
43080   arg2 = (unsigned int)jarg2;
43081   arg3 = (Dali::Pixel::Format)jarg3;
43082   arg4 = (Dali::RenderBuffer::Format)jarg4;
43083   {
43084     try {
43085       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43086     } catch (std::out_of_range& e) {
43087       {
43088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43089       };
43090     } catch (std::exception& e) {
43091       {
43092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43093       };
43094     } catch (...) {
43095       {
43096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43097       };
43098     }
43099   }
43100   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43101   return jresult;
43102 }
43103
43104
43105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43106   void * jresult ;
43107   unsigned int arg1 ;
43108   unsigned int arg2 ;
43109   Dali::Pixel::Format arg3 ;
43110   Dali::FrameBufferImage result;
43111
43112   arg1 = (unsigned int)jarg1;
43113   arg2 = (unsigned int)jarg2;
43114   arg3 = (Dali::Pixel::Format)jarg3;
43115   {
43116     try {
43117       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43118     } catch (std::out_of_range& e) {
43119       {
43120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43121       };
43122     } catch (std::exception& e) {
43123       {
43124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43125       };
43126     } catch (...) {
43127       {
43128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43129       };
43130     }
43131   }
43132   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43133   return jresult;
43134 }
43135
43136
43137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43138   void * jresult ;
43139   unsigned int arg1 ;
43140   unsigned int arg2 ;
43141   Dali::FrameBufferImage result;
43142
43143   arg1 = (unsigned int)jarg1;
43144   arg2 = (unsigned int)jarg2;
43145   {
43146     try {
43147       result = Dali::FrameBufferImage::New(arg1,arg2);
43148     } catch (std::out_of_range& e) {
43149       {
43150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43151       };
43152     } catch (std::exception& e) {
43153       {
43154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43155       };
43156     } catch (...) {
43157       {
43158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43159       };
43160     }
43161   }
43162   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43163   return jresult;
43164 }
43165
43166
43167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43168   void * jresult ;
43169   unsigned int arg1 ;
43170   Dali::FrameBufferImage result;
43171
43172   arg1 = (unsigned int)jarg1;
43173   {
43174     try {
43175       result = Dali::FrameBufferImage::New(arg1);
43176     } catch (std::out_of_range& e) {
43177       {
43178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43179       };
43180     } catch (std::exception& e) {
43181       {
43182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43183       };
43184     } catch (...) {
43185       {
43186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43187       };
43188     }
43189   }
43190   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43191   return jresult;
43192 }
43193
43194
43195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43196   void * jresult ;
43197   Dali::FrameBufferImage result;
43198
43199   {
43200     try {
43201       result = Dali::FrameBufferImage::New();
43202     } catch (std::out_of_range& e) {
43203       {
43204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43205       };
43206     } catch (std::exception& e) {
43207       {
43208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43209       };
43210     } catch (...) {
43211       {
43212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43213       };
43214     }
43215   }
43216   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43222   void * jresult ;
43223   Dali::NativeImageInterface *arg1 = 0 ;
43224   Dali::FrameBufferImage result;
43225
43226   arg1 = (Dali::NativeImageInterface *)jarg1;
43227   if (!arg1) {
43228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43229     return 0;
43230   }
43231   {
43232     try {
43233       result = Dali::FrameBufferImage::New(*arg1);
43234     } catch (std::out_of_range& e) {
43235       {
43236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43237       };
43238     } catch (std::exception& e) {
43239       {
43240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43241       };
43242     } catch (...) {
43243       {
43244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43245       };
43246     }
43247   }
43248   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43249   return jresult;
43250 }
43251
43252
43253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43254   void * jresult ;
43255   Dali::BaseHandle arg1 ;
43256   Dali::BaseHandle *argp1 ;
43257   Dali::FrameBufferImage result;
43258
43259   argp1 = (Dali::BaseHandle *)jarg1;
43260   if (!argp1) {
43261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43262     return 0;
43263   }
43264   arg1 = *argp1;
43265   {
43266     try {
43267       result = Dali::FrameBufferImage::DownCast(arg1);
43268     } catch (std::out_of_range& e) {
43269       {
43270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43271       };
43272     } catch (std::exception& e) {
43273       {
43274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43275       };
43276     } catch (...) {
43277       {
43278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43279       };
43280     }
43281   }
43282   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43283   return jresult;
43284 }
43285
43286
43287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43288   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43289
43290   arg1 = (Dali::FrameBufferImage *)jarg1;
43291   {
43292     try {
43293       delete arg1;
43294     } catch (std::out_of_range& e) {
43295       {
43296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43297       };
43298     } catch (std::exception& e) {
43299       {
43300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43301       };
43302     } catch (...) {
43303       {
43304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43305       };
43306     }
43307   }
43308 }
43309
43310
43311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43312   void * jresult ;
43313   Dali::FrameBufferImage *arg1 = 0 ;
43314   Dali::FrameBufferImage *result = 0 ;
43315
43316   arg1 = (Dali::FrameBufferImage *)jarg1;
43317   if (!arg1) {
43318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43319     return 0;
43320   }
43321   {
43322     try {
43323       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43324     } catch (std::out_of_range& e) {
43325       {
43326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43327       };
43328     } catch (std::exception& e) {
43329       {
43330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43331       };
43332     } catch (...) {
43333       {
43334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43335       };
43336     }
43337   }
43338   jresult = (void *)result;
43339   return jresult;
43340 }
43341
43342
43343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43344   void * jresult ;
43345   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43346   Dali::FrameBufferImage *arg2 = 0 ;
43347   Dali::FrameBufferImage *result = 0 ;
43348
43349   arg1 = (Dali::FrameBufferImage *)jarg1;
43350   arg2 = (Dali::FrameBufferImage *)jarg2;
43351   if (!arg2) {
43352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43353     return 0;
43354   }
43355   {
43356     try {
43357       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43358     } catch (std::out_of_range& e) {
43359       {
43360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43361       };
43362     } catch (std::exception& e) {
43363       {
43364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43365       };
43366     } catch (...) {
43367       {
43368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43369       };
43370     }
43371   }
43372   jresult = (void *)result;
43373   return jresult;
43374 }
43375
43376
43377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43378   void * jresult ;
43379   Dali::NinePatchImage *result = 0 ;
43380
43381   {
43382     try {
43383       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43384     } catch (std::out_of_range& e) {
43385       {
43386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43387       };
43388     } catch (std::exception& e) {
43389       {
43390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43391       };
43392     } catch (...) {
43393       {
43394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43395       };
43396     }
43397   }
43398   jresult = (void *)result;
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43404   void * jresult ;
43405   std::string *arg1 = 0 ;
43406   Dali::NinePatchImage result;
43407
43408   if (!jarg1) {
43409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43410     return 0;
43411   }
43412   std::string arg1_str(jarg1);
43413   arg1 = &arg1_str;
43414   {
43415     try {
43416       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43417     } catch (std::out_of_range& e) {
43418       {
43419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43420       };
43421     } catch (std::exception& e) {
43422       {
43423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43424       };
43425     } catch (...) {
43426       {
43427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43428       };
43429     }
43430   }
43431   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43432
43433   //argout typemap for const std::string&
43434
43435   return jresult;
43436 }
43437
43438
43439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43440   void * jresult ;
43441   Dali::BaseHandle arg1 ;
43442   Dali::BaseHandle *argp1 ;
43443   Dali::NinePatchImage result;
43444
43445   argp1 = (Dali::BaseHandle *)jarg1;
43446   if (!argp1) {
43447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43448     return 0;
43449   }
43450   arg1 = *argp1;
43451   {
43452     try {
43453       result = Dali::NinePatchImage::DownCast(arg1);
43454     } catch (std::out_of_range& e) {
43455       {
43456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43457       };
43458     } catch (std::exception& e) {
43459       {
43460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43461       };
43462     } catch (...) {
43463       {
43464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43465       };
43466     }
43467   }
43468   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43469   return jresult;
43470 }
43471
43472
43473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43474   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43475
43476   arg1 = (Dali::NinePatchImage *)jarg1;
43477   {
43478     try {
43479       delete arg1;
43480     } catch (std::out_of_range& e) {
43481       {
43482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43483       };
43484     } catch (std::exception& e) {
43485       {
43486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43487       };
43488     } catch (...) {
43489       {
43490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43491       };
43492     }
43493   }
43494 }
43495
43496
43497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43498   void * jresult ;
43499   Dali::NinePatchImage *arg1 = 0 ;
43500   Dali::NinePatchImage *result = 0 ;
43501
43502   arg1 = (Dali::NinePatchImage *)jarg1;
43503   if (!arg1) {
43504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43505     return 0;
43506   }
43507   {
43508     try {
43509       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43510     } catch (std::out_of_range& e) {
43511       {
43512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43513       };
43514     } catch (std::exception& e) {
43515       {
43516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43517       };
43518     } catch (...) {
43519       {
43520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43521       };
43522     }
43523   }
43524   jresult = (void *)result;
43525   return jresult;
43526 }
43527
43528
43529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43530   void * jresult ;
43531   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43532   Dali::NinePatchImage *arg2 = 0 ;
43533   Dali::NinePatchImage *result = 0 ;
43534
43535   arg1 = (Dali::NinePatchImage *)jarg1;
43536   arg2 = (Dali::NinePatchImage *)jarg2;
43537   if (!arg2) {
43538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43539     return 0;
43540   }
43541   {
43542     try {
43543       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43544     } catch (std::out_of_range& e) {
43545       {
43546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43547       };
43548     } catch (std::exception& e) {
43549       {
43550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43551       };
43552     } catch (...) {
43553       {
43554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43555       };
43556     }
43557   }
43558   jresult = (void *)result;
43559   return jresult;
43560 }
43561
43562
43563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43564   void * jresult ;
43565   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43566   Dali::Vector4 result;
43567
43568   arg1 = (Dali::NinePatchImage *)jarg1;
43569   {
43570     try {
43571       result = (arg1)->GetStretchBorders();
43572     } catch (std::out_of_range& e) {
43573       {
43574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43575       };
43576     } catch (std::exception& e) {
43577       {
43578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43579       };
43580     } catch (...) {
43581       {
43582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43583       };
43584     }
43585   }
43586   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43587   return jresult;
43588 }
43589
43590
43591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43592   void * jresult ;
43593   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43594   Dali::NinePatchImage::StretchRanges *result = 0 ;
43595
43596   arg1 = (Dali::NinePatchImage *)jarg1;
43597   {
43598     try {
43599       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43600     } catch (std::out_of_range& e) {
43601       {
43602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43603       };
43604     } catch (std::exception& e) {
43605       {
43606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43607       };
43608     } catch (...) {
43609       {
43610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43611       };
43612     }
43613   }
43614   jresult = (void *)result;
43615   return jresult;
43616 }
43617
43618
43619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43620   void * jresult ;
43621   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43622   Dali::NinePatchImage::StretchRanges *result = 0 ;
43623
43624   arg1 = (Dali::NinePatchImage *)jarg1;
43625   {
43626     try {
43627       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43628     } catch (std::out_of_range& e) {
43629       {
43630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43631       };
43632     } catch (std::exception& e) {
43633       {
43634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43635       };
43636     } catch (...) {
43637       {
43638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43639       };
43640     }
43641   }
43642   jresult = (void *)result;
43643   return jresult;
43644 }
43645
43646
43647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43648   void * jresult ;
43649   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43650   Dali::Rect< int > result;
43651
43652   arg1 = (Dali::NinePatchImage *)jarg1;
43653   {
43654     try {
43655       result = (arg1)->GetChildRectangle();
43656     } catch (std::out_of_range& e) {
43657       {
43658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43659       };
43660     } catch (std::exception& e) {
43661       {
43662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (...) {
43665       {
43666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43667       };
43668     }
43669   }
43670   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43671   return jresult;
43672 }
43673
43674
43675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43676   void * jresult ;
43677   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43678   Dali::BufferImage result;
43679
43680   arg1 = (Dali::NinePatchImage *)jarg1;
43681   {
43682     try {
43683       result = (arg1)->CreateCroppedBufferImage();
43684     } catch (std::out_of_range& e) {
43685       {
43686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43687       };
43688     } catch (std::exception& e) {
43689       {
43690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43691       };
43692     } catch (...) {
43693       {
43694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43695       };
43696     }
43697   }
43698   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43699   return jresult;
43700 }
43701
43702
43703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43704   unsigned int jresult ;
43705   std::string *arg1 = 0 ;
43706   bool result;
43707
43708   if (!jarg1) {
43709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43710     return 0;
43711   }
43712   std::string arg1_str(jarg1);
43713   arg1 = &arg1_str;
43714   {
43715     try {
43716       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43717     } catch (std::out_of_range& e) {
43718       {
43719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43720       };
43721     } catch (std::exception& e) {
43722       {
43723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (...) {
43726       {
43727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43728       };
43729     }
43730   }
43731   jresult = result;
43732
43733   //argout typemap for const std::string&
43734
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43740   int jresult ;
43741   int result;
43742
43743   result = (int)Dali::CameraActor::Property::TYPE;
43744   jresult = (int)result;
43745   return jresult;
43746 }
43747
43748
43749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43750   int jresult ;
43751   int result;
43752
43753   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43754   jresult = (int)result;
43755   return jresult;
43756 }
43757
43758
43759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43760   int jresult ;
43761   int result;
43762
43763   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43764   jresult = (int)result;
43765   return jresult;
43766 }
43767
43768
43769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43770   int jresult ;
43771   int result;
43772
43773   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43774   jresult = (int)result;
43775   return jresult;
43776 }
43777
43778
43779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43780   int jresult ;
43781   int result;
43782
43783   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43784   jresult = (int)result;
43785   return jresult;
43786 }
43787
43788
43789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43790   int jresult ;
43791   int result;
43792
43793   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43794   jresult = (int)result;
43795   return jresult;
43796 }
43797
43798
43799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43800   int jresult ;
43801   int result;
43802
43803   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43804   jresult = (int)result;
43805   return jresult;
43806 }
43807
43808
43809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43810   int jresult ;
43811   int result;
43812
43813   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43814   jresult = (int)result;
43815   return jresult;
43816 }
43817
43818
43819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43820   int jresult ;
43821   int result;
43822
43823   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43824   jresult = (int)result;
43825   return jresult;
43826 }
43827
43828
43829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43830   int jresult ;
43831   int result;
43832
43833   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43834   jresult = (int)result;
43835   return jresult;
43836 }
43837
43838
43839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43840   int jresult ;
43841   int result;
43842
43843   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43844   jresult = (int)result;
43845   return jresult;
43846 }
43847
43848
43849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43850   int jresult ;
43851   int result;
43852
43853   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43854   jresult = (int)result;
43855   return jresult;
43856 }
43857
43858
43859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43860   int jresult ;
43861   int result;
43862
43863   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43864   jresult = (int)result;
43865   return jresult;
43866 }
43867
43868
43869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43870   int jresult ;
43871   int result;
43872
43873   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43874   jresult = (int)result;
43875   return jresult;
43876 }
43877
43878
43879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43880   void * jresult ;
43881   Dali::CameraActor::Property *result = 0 ;
43882
43883   {
43884     try {
43885       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43886     } catch (std::out_of_range& e) {
43887       {
43888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43889       };
43890     } catch (std::exception& e) {
43891       {
43892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43893       };
43894     } catch (...) {
43895       {
43896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43897       };
43898     }
43899   }
43900   jresult = (void *)result;
43901   return jresult;
43902 }
43903
43904
43905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43906   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43907
43908   arg1 = (Dali::CameraActor::Property *)jarg1;
43909   {
43910     try {
43911       delete arg1;
43912     } catch (std::out_of_range& e) {
43913       {
43914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43915       };
43916     } catch (std::exception& e) {
43917       {
43918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43919       };
43920     } catch (...) {
43921       {
43922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43923       };
43924     }
43925   }
43926 }
43927
43928
43929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43930   void * jresult ;
43931   Dali::CameraActor *result = 0 ;
43932
43933   {
43934     try {
43935       result = (Dali::CameraActor *)new Dali::CameraActor();
43936     } catch (std::out_of_range& e) {
43937       {
43938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43939       };
43940     } catch (std::exception& e) {
43941       {
43942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43943       };
43944     } catch (...) {
43945       {
43946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43947       };
43948     }
43949   }
43950   jresult = (void *)result;
43951   return jresult;
43952 }
43953
43954
43955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43956   void * jresult ;
43957   Dali::CameraActor result;
43958
43959   {
43960     try {
43961       result = Dali::CameraActor::New();
43962     } catch (std::out_of_range& e) {
43963       {
43964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43965       };
43966     } catch (std::exception& e) {
43967       {
43968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43969       };
43970     } catch (...) {
43971       {
43972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43973       };
43974     }
43975   }
43976   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43977   return jresult;
43978 }
43979
43980
43981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43982   void * jresult ;
43983   Dali::Size *arg1 = 0 ;
43984   Dali::CameraActor result;
43985
43986   arg1 = (Dali::Size *)jarg1;
43987   if (!arg1) {
43988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43989     return 0;
43990   }
43991   {
43992     try {
43993       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43994     } catch (std::out_of_range& e) {
43995       {
43996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43997       };
43998     } catch (std::exception& e) {
43999       {
44000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44001       };
44002     } catch (...) {
44003       {
44004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44005       };
44006     }
44007   }
44008   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44009   return jresult;
44010 }
44011
44012
44013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44014   void * jresult ;
44015   Dali::BaseHandle arg1 ;
44016   Dali::BaseHandle *argp1 ;
44017   Dali::CameraActor result;
44018
44019   argp1 = (Dali::BaseHandle *)jarg1;
44020   if (!argp1) {
44021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44022     return 0;
44023   }
44024   arg1 = *argp1;
44025   {
44026     try {
44027       result = Dali::CameraActor::DownCast(arg1);
44028     } catch (std::out_of_range& e) {
44029       {
44030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44031       };
44032     } catch (std::exception& e) {
44033       {
44034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44035       };
44036     } catch (...) {
44037       {
44038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44039       };
44040     }
44041   }
44042   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44043   return jresult;
44044 }
44045
44046
44047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44048   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44049
44050   arg1 = (Dali::CameraActor *)jarg1;
44051   {
44052     try {
44053       delete arg1;
44054     } catch (std::out_of_range& e) {
44055       {
44056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44057       };
44058     } catch (std::exception& e) {
44059       {
44060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44061       };
44062     } catch (...) {
44063       {
44064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44065       };
44066     }
44067   }
44068 }
44069
44070
44071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44072   void * jresult ;
44073   Dali::CameraActor *arg1 = 0 ;
44074   Dali::CameraActor *result = 0 ;
44075
44076   arg1 = (Dali::CameraActor *)jarg1;
44077   if (!arg1) {
44078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44079     return 0;
44080   }
44081   {
44082     try {
44083       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44084     } catch (std::out_of_range& e) {
44085       {
44086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44087       };
44088     } catch (std::exception& e) {
44089       {
44090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44091       };
44092     } catch (...) {
44093       {
44094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44095       };
44096     }
44097   }
44098   jresult = (void *)result;
44099   return jresult;
44100 }
44101
44102
44103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44104   void * jresult ;
44105   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44106   Dali::CameraActor *arg2 = 0 ;
44107   Dali::CameraActor *result = 0 ;
44108
44109   arg1 = (Dali::CameraActor *)jarg1;
44110   arg2 = (Dali::CameraActor *)jarg2;
44111   if (!arg2) {
44112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44113     return 0;
44114   }
44115   {
44116     try {
44117       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44118     } catch (std::out_of_range& e) {
44119       {
44120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44121       };
44122     } catch (std::exception& e) {
44123       {
44124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44125       };
44126     } catch (...) {
44127       {
44128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44129       };
44130     }
44131   }
44132   jresult = (void *)result;
44133   return jresult;
44134 }
44135
44136
44137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44138   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44139   Dali::Camera::Type arg2 ;
44140
44141   arg1 = (Dali::CameraActor *)jarg1;
44142   arg2 = (Dali::Camera::Type)jarg2;
44143   {
44144     try {
44145       (arg1)->SetType(arg2);
44146     } catch (std::out_of_range& e) {
44147       {
44148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44149       };
44150     } catch (std::exception& e) {
44151       {
44152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44153       };
44154     } catch (...) {
44155       {
44156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44157       };
44158     }
44159   }
44160 }
44161
44162
44163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44164   int jresult ;
44165   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44166   Dali::Camera::Type result;
44167
44168   arg1 = (Dali::CameraActor *)jarg1;
44169   {
44170     try {
44171       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44172     } catch (std::out_of_range& e) {
44173       {
44174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44175       };
44176     } catch (std::exception& e) {
44177       {
44178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44179       };
44180     } catch (...) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44183       };
44184     }
44185   }
44186   jresult = (int)result;
44187   return jresult;
44188 }
44189
44190
44191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44192   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44193   Dali::Camera::ProjectionMode arg2 ;
44194
44195   arg1 = (Dali::CameraActor *)jarg1;
44196   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44197   {
44198     try {
44199       (arg1)->SetProjectionMode(arg2);
44200     } catch (std::out_of_range& e) {
44201       {
44202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44203       };
44204     } catch (std::exception& e) {
44205       {
44206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44207       };
44208     } catch (...) {
44209       {
44210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44211       };
44212     }
44213   }
44214 }
44215
44216
44217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44218   int jresult ;
44219   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44220   Dali::Camera::ProjectionMode result;
44221
44222   arg1 = (Dali::CameraActor *)jarg1;
44223   {
44224     try {
44225       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44226     } catch (std::out_of_range& e) {
44227       {
44228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44229       };
44230     } catch (std::exception& e) {
44231       {
44232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44233       };
44234     } catch (...) {
44235       {
44236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44237       };
44238     }
44239   }
44240   jresult = (int)result;
44241   return jresult;
44242 }
44243
44244
44245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44246   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44247   float arg2 ;
44248
44249   arg1 = (Dali::CameraActor *)jarg1;
44250   arg2 = (float)jarg2;
44251   {
44252     try {
44253       (arg1)->SetFieldOfView(arg2);
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44261       };
44262     } catch (...) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44265       };
44266     }
44267   }
44268 }
44269
44270
44271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44272   float jresult ;
44273   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44274   float result;
44275
44276   arg1 = (Dali::CameraActor *)jarg1;
44277   {
44278     try {
44279       result = (float)(arg1)->GetFieldOfView();
44280     } catch (std::out_of_range& e) {
44281       {
44282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44283       };
44284     } catch (std::exception& e) {
44285       {
44286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44287       };
44288     } catch (...) {
44289       {
44290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44291       };
44292     }
44293   }
44294   jresult = result;
44295   return jresult;
44296 }
44297
44298
44299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44300   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44301   float arg2 ;
44302
44303   arg1 = (Dali::CameraActor *)jarg1;
44304   arg2 = (float)jarg2;
44305   {
44306     try {
44307       (arg1)->SetAspectRatio(arg2);
44308     } catch (std::out_of_range& e) {
44309       {
44310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44311       };
44312     } catch (std::exception& e) {
44313       {
44314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44315       };
44316     } catch (...) {
44317       {
44318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44319       };
44320     }
44321   }
44322 }
44323
44324
44325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44326   float jresult ;
44327   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44328   float result;
44329
44330   arg1 = (Dali::CameraActor *)jarg1;
44331   {
44332     try {
44333       result = (float)(arg1)->GetAspectRatio();
44334     } catch (std::out_of_range& e) {
44335       {
44336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44337       };
44338     } catch (std::exception& e) {
44339       {
44340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44341       };
44342     } catch (...) {
44343       {
44344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44345       };
44346     }
44347   }
44348   jresult = result;
44349   return jresult;
44350 }
44351
44352
44353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44354   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44355   float arg2 ;
44356
44357   arg1 = (Dali::CameraActor *)jarg1;
44358   arg2 = (float)jarg2;
44359   {
44360     try {
44361       (arg1)->SetNearClippingPlane(arg2);
44362     } catch (std::out_of_range& e) {
44363       {
44364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44365       };
44366     } catch (std::exception& e) {
44367       {
44368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44369       };
44370     } catch (...) {
44371       {
44372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44373       };
44374     }
44375   }
44376 }
44377
44378
44379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44380   float jresult ;
44381   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44382   float result;
44383
44384   arg1 = (Dali::CameraActor *)jarg1;
44385   {
44386     try {
44387       result = (float)(arg1)->GetNearClippingPlane();
44388     } catch (std::out_of_range& e) {
44389       {
44390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44391       };
44392     } catch (std::exception& e) {
44393       {
44394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44395       };
44396     } catch (...) {
44397       {
44398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44399       };
44400     }
44401   }
44402   jresult = result;
44403   return jresult;
44404 }
44405
44406
44407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44408   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44409   float arg2 ;
44410
44411   arg1 = (Dali::CameraActor *)jarg1;
44412   arg2 = (float)jarg2;
44413   {
44414     try {
44415       (arg1)->SetFarClippingPlane(arg2);
44416     } catch (std::out_of_range& e) {
44417       {
44418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44419       };
44420     } catch (std::exception& e) {
44421       {
44422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44423       };
44424     } catch (...) {
44425       {
44426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44427       };
44428     }
44429   }
44430 }
44431
44432
44433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44434   float jresult ;
44435   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44436   float result;
44437
44438   arg1 = (Dali::CameraActor *)jarg1;
44439   {
44440     try {
44441       result = (float)(arg1)->GetFarClippingPlane();
44442     } catch (std::out_of_range& e) {
44443       {
44444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44445       };
44446     } catch (std::exception& e) {
44447       {
44448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44449       };
44450     } catch (...) {
44451       {
44452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44453       };
44454     }
44455   }
44456   jresult = result;
44457   return jresult;
44458 }
44459
44460
44461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44462   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44463   Dali::Vector3 *arg2 = 0 ;
44464
44465   arg1 = (Dali::CameraActor *)jarg1;
44466   arg2 = (Dali::Vector3 *)jarg2;
44467   if (!arg2) {
44468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44469     return ;
44470   }
44471   {
44472     try {
44473       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44474     } catch (std::out_of_range& e) {
44475       {
44476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44477       };
44478     } catch (std::exception& e) {
44479       {
44480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44481       };
44482     } catch (...) {
44483       {
44484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44485       };
44486     }
44487   }
44488 }
44489
44490
44491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44492   void * jresult ;
44493   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44494   Dali::Vector3 result;
44495
44496   arg1 = (Dali::CameraActor *)jarg1;
44497   {
44498     try {
44499       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44500     } catch (std::out_of_range& e) {
44501       {
44502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44503       };
44504     } catch (std::exception& e) {
44505       {
44506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44507       };
44508     } catch (...) {
44509       {
44510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44511       };
44512     }
44513   }
44514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44515   return jresult;
44516 }
44517
44518
44519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44520   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44521   bool arg2 ;
44522
44523   arg1 = (Dali::CameraActor *)jarg1;
44524   arg2 = jarg2 ? true : false;
44525   {
44526     try {
44527       (arg1)->SetInvertYAxis(arg2);
44528     } catch (std::out_of_range& e) {
44529       {
44530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44531       };
44532     } catch (std::exception& e) {
44533       {
44534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44535       };
44536     } catch (...) {
44537       {
44538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44539       };
44540     }
44541   }
44542 }
44543
44544
44545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44546   unsigned int jresult ;
44547   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44548   bool result;
44549
44550   arg1 = (Dali::CameraActor *)jarg1;
44551   {
44552     try {
44553       result = (bool)(arg1)->GetInvertYAxis();
44554     } catch (std::out_of_range& e) {
44555       {
44556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44557       };
44558     } catch (std::exception& e) {
44559       {
44560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44561       };
44562     } catch (...) {
44563       {
44564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44565       };
44566     }
44567   }
44568   jresult = result;
44569   return jresult;
44570 }
44571
44572
44573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44574   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44575   Dali::Size *arg2 = 0 ;
44576
44577   arg1 = (Dali::CameraActor *)jarg1;
44578   arg2 = (Dali::Size *)jarg2;
44579   if (!arg2) {
44580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44581     return ;
44582   }
44583   {
44584     try {
44585       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44586     } catch (std::out_of_range& e) {
44587       {
44588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44589       };
44590     } catch (std::exception& e) {
44591       {
44592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44593       };
44594     } catch (...) {
44595       {
44596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44597       };
44598     }
44599   }
44600 }
44601
44602
44603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44604   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44605   Dali::Size *arg2 = 0 ;
44606
44607   arg1 = (Dali::CameraActor *)jarg1;
44608   arg2 = (Dali::Size *)jarg2;
44609   if (!arg2) {
44610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44611     return ;
44612   }
44613   {
44614     try {
44615       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44616     } catch (std::out_of_range& e) {
44617       {
44618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44619       };
44620     } catch (std::exception& e) {
44621       {
44622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44623       };
44624     } catch (...) {
44625       {
44626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44627       };
44628     }
44629   }
44630 }
44631
44632
44633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44634   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44635   float arg2 ;
44636   float arg3 ;
44637   float arg4 ;
44638   float arg5 ;
44639   float arg6 ;
44640   float arg7 ;
44641
44642   arg1 = (Dali::CameraActor *)jarg1;
44643   arg2 = (float)jarg2;
44644   arg3 = (float)jarg3;
44645   arg4 = (float)jarg4;
44646   arg5 = (float)jarg5;
44647   arg6 = (float)jarg6;
44648   arg7 = (float)jarg7;
44649   {
44650     try {
44651       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44652     } catch (std::out_of_range& e) {
44653       {
44654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44655       };
44656     } catch (std::exception& e) {
44657       {
44658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44659       };
44660     } catch (...) {
44661       {
44662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44663       };
44664     }
44665   }
44666 }
44667
44668
44669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44670   void * jresult ;
44671   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44672
44673   {
44674     try {
44675       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44676     } catch (std::out_of_range& e) {
44677       {
44678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44679       };
44680     } catch (std::exception& e) {
44681       {
44682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44683       };
44684     } catch (...) {
44685       {
44686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44687       };
44688     }
44689   }
44690   jresult = (void *)result;
44691   return jresult;
44692 }
44693
44694
44695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44696   void * jresult ;
44697   std::string arg1 ;
44698   Dali::Property::Value arg2 ;
44699   Dali::Property::Value *argp2 ;
44700   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44701
44702   if (!jarg1) {
44703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44704     return 0;
44705   }
44706   (&arg1)->assign(jarg1);
44707   argp2 = (Dali::Property::Value *)jarg2;
44708   if (!argp2) {
44709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44710     return 0;
44711   }
44712   arg2 = *argp2;
44713   {
44714     try {
44715       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44716     } catch (std::out_of_range& e) {
44717       {
44718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44719       };
44720     } catch (std::exception& e) {
44721       {
44722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44723       };
44724     } catch (...) {
44725       {
44726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44727       };
44728     }
44729   }
44730   jresult = (void *)result;
44731   return jresult;
44732 }
44733
44734
44735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44736   void * jresult ;
44737   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44738   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44739
44740   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44741   if (!arg1) {
44742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44743     return 0;
44744   }
44745   {
44746     try {
44747       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);
44748     } catch (std::out_of_range& e) {
44749       {
44750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44751       };
44752     } catch (std::exception& e) {
44753       {
44754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44755       };
44756     } catch (...) {
44757       {
44758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44759       };
44760     }
44761   }
44762   jresult = (void *)result;
44763   return jresult;
44764 }
44765
44766
44767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44768   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44769   std::string *arg2 = 0 ;
44770
44771   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44772   if (!jarg2) {
44773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44774     return ;
44775   }
44776   std::string arg2_str(jarg2);
44777   arg2 = &arg2_str;
44778   if (arg1) (arg1)->first = *arg2;
44779
44780   //argout typemap for const std::string&
44781
44782 }
44783
44784
44785 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44786   char * jresult ;
44787   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44788   std::string *result = 0 ;
44789
44790   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44791   result = (std::string *) & ((arg1)->first);
44792   jresult = SWIG_csharp_string_callback(result->c_str());
44793   return jresult;
44794 }
44795
44796
44797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44798   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44799   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44800
44801   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44802   arg2 = (Dali::Property::Value *)jarg2;
44803   if (arg1) (arg1)->second = *arg2;
44804 }
44805
44806
44807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44808   void * jresult ;
44809   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44810   Dali::Property::Value *result = 0 ;
44811
44812   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44813   result = (Dali::Property::Value *)& ((arg1)->second);
44814   jresult = (void *)result;
44815   return jresult;
44816 }
44817
44818
44819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44820   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44821
44822   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44823   {
44824     try {
44825       delete arg1;
44826     } catch (std::out_of_range& e) {
44827       {
44828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (std::exception& e) {
44831       {
44832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840 }
44841
44842
44843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44844   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44845
44846   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44847   {
44848     try {
44849       (arg1)->clear();
44850     } catch (std::out_of_range& e) {
44851       {
44852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44853       };
44854     } catch (std::exception& e) {
44855       {
44856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44857       };
44858     } catch (...) {
44859       {
44860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44861       };
44862     }
44863   }
44864 }
44865
44866
44867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44868   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44869   Dali::TouchPoint *arg2 = 0 ;
44870
44871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44872   arg2 = (Dali::TouchPoint *)jarg2;
44873   if (!arg2) {
44874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44875     return ;
44876   }
44877   {
44878     try {
44879       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44880     } catch (std::out_of_range& e) {
44881       {
44882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44883       };
44884     } catch (std::exception& e) {
44885       {
44886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44887       };
44888     } catch (...) {
44889       {
44890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44891       };
44892     }
44893   }
44894 }
44895
44896
44897 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44898   unsigned long jresult ;
44899   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44900   std::vector< Dali::TouchPoint >::size_type result;
44901
44902   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44903   {
44904     try {
44905       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44906     } catch (std::out_of_range& e) {
44907       {
44908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44909       };
44910     } catch (std::exception& e) {
44911       {
44912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44913       };
44914     } catch (...) {
44915       {
44916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44917       };
44918     }
44919   }
44920   jresult = (unsigned long)result;
44921   return jresult;
44922 }
44923
44924
44925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44926   unsigned long jresult ;
44927   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44928   std::vector< Dali::TouchPoint >::size_type result;
44929
44930   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44931   {
44932     try {
44933       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44934     } catch (std::out_of_range& e) {
44935       {
44936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (std::exception& e) {
44939       {
44940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (...) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44945       };
44946     }
44947   }
44948   jresult = (unsigned long)result;
44949   return jresult;
44950 }
44951
44952
44953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44954   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44955   std::vector< Dali::TouchPoint >::size_type arg2 ;
44956
44957   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44958   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44959   {
44960     try {
44961       (arg1)->reserve(arg2);
44962     } catch (std::out_of_range& e) {
44963       {
44964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44965       };
44966     } catch (std::exception& e) {
44967       {
44968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44969       };
44970     } catch (...) {
44971       {
44972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44973       };
44974     }
44975   }
44976 }
44977
44978
44979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44980   void * jresult ;
44981   std::vector< Dali::TouchPoint > *result = 0 ;
44982
44983   {
44984     try {
44985       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44986     } catch (std::out_of_range& e) {
44987       {
44988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44989       };
44990     } catch (std::exception& e) {
44991       {
44992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44993       };
44994     } catch (...) {
44995       {
44996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44997       };
44998     }
44999   }
45000   jresult = (void *)result;
45001   return jresult;
45002 }
45003
45004
45005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45006   void * jresult ;
45007   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45008   std::vector< Dali::TouchPoint > *result = 0 ;
45009
45010   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45011   if (!arg1) {
45012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45013     return 0;
45014   }
45015   {
45016     try {
45017       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45018     } catch (std::out_of_range& e) {
45019       {
45020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45021       };
45022     } catch (std::exception& e) {
45023       {
45024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45025       };
45026     } catch (...) {
45027       {
45028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45029       };
45030     }
45031   }
45032   jresult = (void *)result;
45033   return jresult;
45034 }
45035
45036
45037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45038   void * jresult ;
45039   int arg1 ;
45040   std::vector< Dali::TouchPoint > *result = 0 ;
45041
45042   arg1 = (int)jarg1;
45043   {
45044     try {
45045       try {
45046         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45047       }
45048       catch(std::out_of_range &_e) {
45049         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45050         return 0;
45051       }
45052
45053     } catch (std::out_of_range& e) {
45054       {
45055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45056       };
45057     } catch (std::exception& e) {
45058       {
45059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45060       };
45061     } catch (...) {
45062       {
45063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45064       };
45065     }
45066   }
45067   jresult = (void *)result;
45068   return jresult;
45069 }
45070
45071
45072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45073   void * jresult ;
45074   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45075   int arg2 ;
45076   SwigValueWrapper< Dali::TouchPoint > result;
45077
45078   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45079   arg2 = (int)jarg2;
45080   {
45081     try {
45082       try {
45083         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45084       }
45085       catch(std::out_of_range &_e) {
45086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45087         return 0;
45088       }
45089
45090     } catch (std::out_of_range& e) {
45091       {
45092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45093       };
45094     } catch (std::exception& e) {
45095       {
45096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45097       };
45098     } catch (...) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45101       };
45102     }
45103   }
45104   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45105   return jresult;
45106 }
45107
45108
45109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45110   void * jresult ;
45111   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45112   int arg2 ;
45113   Dali::TouchPoint *result = 0 ;
45114
45115   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45116   arg2 = (int)jarg2;
45117   {
45118     try {
45119       try {
45120         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45121       }
45122       catch(std::out_of_range &_e) {
45123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45124         return 0;
45125       }
45126
45127     } catch (std::out_of_range& e) {
45128       {
45129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (std::exception& e) {
45132       {
45133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45134       };
45135     } catch (...) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45138       };
45139     }
45140   }
45141   jresult = (void *)result;
45142   return jresult;
45143 }
45144
45145
45146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45147   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45148   int arg2 ;
45149   Dali::TouchPoint *arg3 = 0 ;
45150
45151   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45152   arg2 = (int)jarg2;
45153   arg3 = (Dali::TouchPoint *)jarg3;
45154   if (!arg3) {
45155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45156     return ;
45157   }
45158   {
45159     try {
45160       try {
45161         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45162       }
45163       catch(std::out_of_range &_e) {
45164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45165         return ;
45166       }
45167
45168     } catch (std::out_of_range& e) {
45169       {
45170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45171       };
45172     } catch (std::exception& e) {
45173       {
45174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45175       };
45176     } catch (...) {
45177       {
45178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45179       };
45180     }
45181   }
45182 }
45183
45184
45185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45186   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45187   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45188
45189   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45190   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45191   if (!arg2) {
45192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45193     return ;
45194   }
45195   {
45196     try {
45197       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45198     } catch (std::out_of_range& e) {
45199       {
45200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45201       };
45202     } catch (std::exception& e) {
45203       {
45204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45209       };
45210     }
45211   }
45212 }
45213
45214
45215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45216   void * jresult ;
45217   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45218   int arg2 ;
45219   int arg3 ;
45220   std::vector< Dali::TouchPoint > *result = 0 ;
45221
45222   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45223   arg2 = (int)jarg2;
45224   arg3 = (int)jarg3;
45225   {
45226     try {
45227       try {
45228         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45229       }
45230       catch(std::out_of_range &_e) {
45231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45232         return 0;
45233       }
45234       catch(std::invalid_argument &_e) {
45235         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45236         return 0;
45237       }
45238
45239     } catch (std::out_of_range& e) {
45240       {
45241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45242       };
45243     } catch (std::exception& e) {
45244       {
45245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45246       };
45247     } catch (...) {
45248       {
45249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45250       };
45251     }
45252   }
45253   jresult = (void *)result;
45254   return jresult;
45255 }
45256
45257
45258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45259   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45260   int arg2 ;
45261   Dali::TouchPoint *arg3 = 0 ;
45262
45263   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45264   arg2 = (int)jarg2;
45265   arg3 = (Dali::TouchPoint *)jarg3;
45266   if (!arg3) {
45267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45268     return ;
45269   }
45270   {
45271     try {
45272       try {
45273         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45274       }
45275       catch(std::out_of_range &_e) {
45276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45277         return ;
45278       }
45279
45280     } catch (std::out_of_range& e) {
45281       {
45282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45283       };
45284     } catch (std::exception& e) {
45285       {
45286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45287       };
45288     } catch (...) {
45289       {
45290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45291       };
45292     }
45293   }
45294 }
45295
45296
45297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45298   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45299   int arg2 ;
45300   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45301
45302   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45303   arg2 = (int)jarg2;
45304   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45305   if (!arg3) {
45306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45307     return ;
45308   }
45309   {
45310     try {
45311       try {
45312         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45313       }
45314       catch(std::out_of_range &_e) {
45315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45316         return ;
45317       }
45318
45319     } catch (std::out_of_range& e) {
45320       {
45321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45322       };
45323     } catch (std::exception& e) {
45324       {
45325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45326       };
45327     } catch (...) {
45328       {
45329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45330       };
45331     }
45332   }
45333 }
45334
45335
45336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45337   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45338   int arg2 ;
45339
45340   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45341   arg2 = (int)jarg2;
45342   {
45343     try {
45344       try {
45345         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45346       }
45347       catch(std::out_of_range &_e) {
45348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45349         return ;
45350       }
45351
45352     } catch (std::out_of_range& e) {
45353       {
45354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45355       };
45356     } catch (std::exception& e) {
45357       {
45358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45359       };
45360     } catch (...) {
45361       {
45362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45363       };
45364     }
45365   }
45366 }
45367
45368
45369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45370   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45371   int arg2 ;
45372   int arg3 ;
45373
45374   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45375   arg2 = (int)jarg2;
45376   arg3 = (int)jarg3;
45377   {
45378     try {
45379       try {
45380         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45381       }
45382       catch(std::out_of_range &_e) {
45383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45384         return ;
45385       }
45386       catch(std::invalid_argument &_e) {
45387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45388         return ;
45389       }
45390
45391     } catch (std::out_of_range& e) {
45392       {
45393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45394       };
45395     } catch (std::exception& e) {
45396       {
45397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45398       };
45399     } catch (...) {
45400       {
45401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45402       };
45403     }
45404   }
45405 }
45406
45407
45408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45409   void * jresult ;
45410   Dali::TouchPoint *arg1 = 0 ;
45411   int arg2 ;
45412   std::vector< Dali::TouchPoint > *result = 0 ;
45413
45414   arg1 = (Dali::TouchPoint *)jarg1;
45415   if (!arg1) {
45416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45417     return 0;
45418   }
45419   arg2 = (int)jarg2;
45420   {
45421     try {
45422       try {
45423         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45424       }
45425       catch(std::out_of_range &_e) {
45426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45427         return 0;
45428       }
45429
45430     } catch (std::out_of_range& e) {
45431       {
45432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45433       };
45434     } catch (std::exception& e) {
45435       {
45436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (...) {
45439       {
45440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45441       };
45442     }
45443   }
45444   jresult = (void *)result;
45445   return jresult;
45446 }
45447
45448
45449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45450   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45451
45452   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45453   {
45454     try {
45455       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45456     } catch (std::out_of_range& e) {
45457       {
45458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45459       };
45460     } catch (std::exception& e) {
45461       {
45462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45463       };
45464     } catch (...) {
45465       {
45466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45467       };
45468     }
45469   }
45470 }
45471
45472
45473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45474   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45475   int arg2 ;
45476   int arg3 ;
45477
45478   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45479   arg2 = (int)jarg2;
45480   arg3 = (int)jarg3;
45481   {
45482     try {
45483       try {
45484         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45485       }
45486       catch(std::out_of_range &_e) {
45487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45488         return ;
45489       }
45490       catch(std::invalid_argument &_e) {
45491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45492         return ;
45493       }
45494
45495     } catch (std::out_of_range& e) {
45496       {
45497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45498       };
45499     } catch (std::exception& e) {
45500       {
45501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45502       };
45503     } catch (...) {
45504       {
45505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45506       };
45507     }
45508   }
45509 }
45510
45511
45512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45513   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45514   int arg2 ;
45515   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45516
45517   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45518   arg2 = (int)jarg2;
45519   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45520   if (!arg3) {
45521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45522     return ;
45523   }
45524   {
45525     try {
45526       try {
45527         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45528       }
45529       catch(std::out_of_range &_e) {
45530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45531         return ;
45532       }
45533
45534     } catch (std::out_of_range& e) {
45535       {
45536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45537       };
45538     } catch (std::exception& e) {
45539       {
45540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45541       };
45542     } catch (...) {
45543       {
45544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45545       };
45546     }
45547   }
45548 }
45549
45550
45551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45552   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45553
45554   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45555   {
45556     try {
45557       delete arg1;
45558     } catch (std::out_of_range& e) {
45559       {
45560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45561       };
45562     } catch (std::exception& e) {
45563       {
45564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45565       };
45566     } catch (...) {
45567       {
45568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45569       };
45570     }
45571   }
45572 }
45573
45574
45575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45576   void * jresult ;
45577   Dali::Rect< int > *result = 0 ;
45578
45579   {
45580     try {
45581       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45582     } catch (std::out_of_range& e) {
45583       {
45584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45585       };
45586     } catch (std::exception& e) {
45587       {
45588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45589       };
45590     } catch (...) {
45591       {
45592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45593       };
45594     }
45595   }
45596   jresult = (void *)result;
45597   return jresult;
45598 }
45599
45600
45601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45602   void * jresult ;
45603   int arg1 ;
45604   int arg2 ;
45605   int arg3 ;
45606   int arg4 ;
45607   Dali::Rect< int > *result = 0 ;
45608
45609   arg1 = (int)jarg1;
45610   arg2 = (int)jarg2;
45611   arg3 = (int)jarg3;
45612   arg4 = (int)jarg4;
45613   {
45614     try {
45615       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45616     } catch (std::out_of_range& e) {
45617       {
45618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45619       };
45620     } catch (std::exception& e) {
45621       {
45622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45623       };
45624     } catch (...) {
45625       {
45626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45627       };
45628     }
45629   }
45630   jresult = (void *)result;
45631   return jresult;
45632 }
45633
45634
45635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45636   void * jresult ;
45637   Dali::Rect< int > *arg1 = 0 ;
45638   Dali::Rect< int > *result = 0 ;
45639
45640   arg1 = (Dali::Rect< int > *)jarg1;
45641   if (!arg1) {
45642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45643     return 0;
45644   }
45645   {
45646     try {
45647       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45648     } catch (std::out_of_range& e) {
45649       {
45650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45651       };
45652     } catch (std::exception& e) {
45653       {
45654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45655       };
45656     } catch (...) {
45657       {
45658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45659       };
45660     }
45661   }
45662   jresult = (void *)result;
45663   return jresult;
45664 }
45665
45666
45667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45668   void * jresult ;
45669   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45670   Dali::Rect< int > *arg2 = 0 ;
45671   Dali::Rect< int > *result = 0 ;
45672
45673   arg1 = (Dali::Rect< int > *)jarg1;
45674   arg2 = (Dali::Rect< int > *)jarg2;
45675   if (!arg2) {
45676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45677     return 0;
45678   }
45679   {
45680     try {
45681       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45682     } catch (std::out_of_range& e) {
45683       {
45684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45685       };
45686     } catch (std::exception& e) {
45687       {
45688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45689       };
45690     } catch (...) {
45691       {
45692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45693       };
45694     }
45695   }
45696   jresult = (void *)result;
45697   return jresult;
45698 }
45699
45700
45701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45702   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45703   int arg2 ;
45704   int arg3 ;
45705   int arg4 ;
45706   int arg5 ;
45707
45708   arg1 = (Dali::Rect< int > *)jarg1;
45709   arg2 = (int)jarg2;
45710   arg3 = (int)jarg3;
45711   arg4 = (int)jarg4;
45712   arg5 = (int)jarg5;
45713   {
45714     try {
45715       (arg1)->Set(arg2,arg3,arg4,arg5);
45716     } catch (std::out_of_range& e) {
45717       {
45718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45719       };
45720     } catch (std::exception& e) {
45721       {
45722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45723       };
45724     } catch (...) {
45725       {
45726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45727       };
45728     }
45729   }
45730 }
45731
45732
45733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45734   unsigned int jresult ;
45735   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45736   bool result;
45737
45738   arg1 = (Dali::Rect< int > *)jarg1;
45739   {
45740     try {
45741       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45742     } catch (std::out_of_range& e) {
45743       {
45744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45745       };
45746     } catch (std::exception& e) {
45747       {
45748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45749       };
45750     } catch (...) {
45751       {
45752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45753       };
45754     }
45755   }
45756   jresult = result;
45757   return jresult;
45758 }
45759
45760
45761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45762   int jresult ;
45763   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45764   int result;
45765
45766   arg1 = (Dali::Rect< int > *)jarg1;
45767   {
45768     try {
45769       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45770     } catch (std::out_of_range& e) {
45771       {
45772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45773       };
45774     } catch (std::exception& e) {
45775       {
45776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45777       };
45778     } catch (...) {
45779       {
45780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45781       };
45782     }
45783   }
45784   jresult = result;
45785   return jresult;
45786 }
45787
45788
45789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45790   int jresult ;
45791   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45792   int result;
45793
45794   arg1 = (Dali::Rect< int > *)jarg1;
45795   {
45796     try {
45797       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45798     } catch (std::out_of_range& e) {
45799       {
45800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45801       };
45802     } catch (std::exception& e) {
45803       {
45804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45805       };
45806     } catch (...) {
45807       {
45808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45809       };
45810     }
45811   }
45812   jresult = result;
45813   return jresult;
45814 }
45815
45816
45817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45818   int jresult ;
45819   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45820   int result;
45821
45822   arg1 = (Dali::Rect< int > *)jarg1;
45823   {
45824     try {
45825       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45826     } catch (std::out_of_range& e) {
45827       {
45828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45829       };
45830     } catch (std::exception& e) {
45831       {
45832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45833       };
45834     } catch (...) {
45835       {
45836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45837       };
45838     }
45839   }
45840   jresult = result;
45841   return jresult;
45842 }
45843
45844
45845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45846   int jresult ;
45847   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45848   int result;
45849
45850   arg1 = (Dali::Rect< int > *)jarg1;
45851   {
45852     try {
45853       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45854     } catch (std::out_of_range& e) {
45855       {
45856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45857       };
45858     } catch (std::exception& e) {
45859       {
45860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45861       };
45862     } catch (...) {
45863       {
45864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45865       };
45866     }
45867   }
45868   jresult = result;
45869   return jresult;
45870 }
45871
45872
45873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45874   int jresult ;
45875   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45876   int result;
45877
45878   arg1 = (Dali::Rect< int > *)jarg1;
45879   {
45880     try {
45881       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45882     } catch (std::out_of_range& e) {
45883       {
45884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45885       };
45886     } catch (std::exception& e) {
45887       {
45888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45889       };
45890     } catch (...) {
45891       {
45892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45893       };
45894     }
45895   }
45896   jresult = result;
45897   return jresult;
45898 }
45899
45900
45901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45902   unsigned int jresult ;
45903   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45904   Dali::Rect< int > *arg2 = 0 ;
45905   bool result;
45906
45907   arg1 = (Dali::Rect< int > *)jarg1;
45908   arg2 = (Dali::Rect< int > *)jarg2;
45909   if (!arg2) {
45910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45911     return 0;
45912   }
45913   {
45914     try {
45915       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45916     } catch (std::out_of_range& e) {
45917       {
45918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45919       };
45920     } catch (std::exception& e) {
45921       {
45922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45923       };
45924     } catch (...) {
45925       {
45926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45927       };
45928     }
45929   }
45930   jresult = result;
45931   return jresult;
45932 }
45933
45934
45935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45936   unsigned int jresult ;
45937   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45938   Dali::Rect< int > *arg2 = 0 ;
45939   bool result;
45940
45941   arg1 = (Dali::Rect< int > *)jarg1;
45942   arg2 = (Dali::Rect< int > *)jarg2;
45943   if (!arg2) {
45944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45945     return 0;
45946   }
45947   {
45948     try {
45949       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45950     } catch (std::out_of_range& e) {
45951       {
45952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45953       };
45954     } catch (std::exception& e) {
45955       {
45956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45957       };
45958     } catch (...) {
45959       {
45960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45961       };
45962     }
45963   }
45964   jresult = result;
45965   return jresult;
45966 }
45967
45968
45969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45970   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45971   int arg2 ;
45972
45973   arg1 = (Dali::Rect< int > *)jarg1;
45974   arg2 = (int)jarg2;
45975   if (arg1) (arg1)->x = arg2;
45976 }
45977
45978
45979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45980   int jresult ;
45981   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45982   int result;
45983
45984   arg1 = (Dali::Rect< int > *)jarg1;
45985   result = (int) ((arg1)->x);
45986   jresult = result;
45987   return jresult;
45988 }
45989
45990
45991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45992   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45993   int arg2 ;
45994
45995   arg1 = (Dali::Rect< int > *)jarg1;
45996   arg2 = (int)jarg2;
45997   if (arg1) (arg1)->left = arg2;
45998 }
45999
46000
46001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46002   int jresult ;
46003   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46004   int result;
46005
46006   arg1 = (Dali::Rect< int > *)jarg1;
46007   result = (int) ((arg1)->left);
46008   jresult = result;
46009   return jresult;
46010 }
46011
46012
46013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46014   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46015   int arg2 ;
46016
46017   arg1 = (Dali::Rect< int > *)jarg1;
46018   arg2 = (int)jarg2;
46019   if (arg1) (arg1)->y = arg2;
46020 }
46021
46022
46023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46024   int jresult ;
46025   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46026   int result;
46027
46028   arg1 = (Dali::Rect< int > *)jarg1;
46029   result = (int) ((arg1)->y);
46030   jresult = result;
46031   return jresult;
46032 }
46033
46034
46035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46036   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46037   int arg2 ;
46038
46039   arg1 = (Dali::Rect< int > *)jarg1;
46040   arg2 = (int)jarg2;
46041   if (arg1) (arg1)->right = arg2;
46042 }
46043
46044
46045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46046   int jresult ;
46047   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46048   int result;
46049
46050   arg1 = (Dali::Rect< int > *)jarg1;
46051   result = (int) ((arg1)->right);
46052   jresult = result;
46053   return jresult;
46054 }
46055
46056
46057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46058   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46059   int arg2 ;
46060
46061   arg1 = (Dali::Rect< int > *)jarg1;
46062   arg2 = (int)jarg2;
46063   if (arg1) (arg1)->width = arg2;
46064 }
46065
46066
46067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46068   int jresult ;
46069   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46070   int result;
46071
46072   arg1 = (Dali::Rect< int > *)jarg1;
46073   result = (int) ((arg1)->width);
46074   jresult = result;
46075   return jresult;
46076 }
46077
46078
46079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46080   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46081   int arg2 ;
46082
46083   arg1 = (Dali::Rect< int > *)jarg1;
46084   arg2 = (int)jarg2;
46085   if (arg1) (arg1)->bottom = arg2;
46086 }
46087
46088
46089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46090   int jresult ;
46091   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46092   int result;
46093
46094   arg1 = (Dali::Rect< int > *)jarg1;
46095   result = (int) ((arg1)->bottom);
46096   jresult = result;
46097   return jresult;
46098 }
46099
46100
46101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46102   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46103   int arg2 ;
46104
46105   arg1 = (Dali::Rect< int > *)jarg1;
46106   arg2 = (int)jarg2;
46107   if (arg1) (arg1)->height = arg2;
46108 }
46109
46110
46111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46112   int jresult ;
46113   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46114   int result;
46115
46116   arg1 = (Dali::Rect< int > *)jarg1;
46117   result = (int) ((arg1)->height);
46118   jresult = result;
46119   return jresult;
46120 }
46121
46122
46123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46124   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46125   int arg2 ;
46126
46127   arg1 = (Dali::Rect< int > *)jarg1;
46128   arg2 = (int)jarg2;
46129   if (arg1) (arg1)->top = arg2;
46130 }
46131
46132
46133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46134   int jresult ;
46135   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46136   int result;
46137
46138   arg1 = (Dali::Rect< int > *)jarg1;
46139   result = (int) ((arg1)->top);
46140   jresult = result;
46141   return jresult;
46142 }
46143
46144
46145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46146   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46147
46148   arg1 = (Dali::Rect< int > *)jarg1;
46149   {
46150     try {
46151       delete arg1;
46152     } catch (std::out_of_range& e) {
46153       {
46154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46155       };
46156     } catch (std::exception& e) {
46157       {
46158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46159       };
46160     } catch (...) {
46161       {
46162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46163       };
46164     }
46165   }
46166 }
46167
46168
46169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46170   void * jresult ;
46171   Dali::Rect< float > *result = 0 ;
46172
46173   {
46174     try {
46175       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46176     } catch (std::out_of_range& e) {
46177       {
46178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46179       };
46180     } catch (std::exception& e) {
46181       {
46182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46183       };
46184     } catch (...) {
46185       {
46186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46187       };
46188     }
46189   }
46190   jresult = (void *)result;
46191   return jresult;
46192 }
46193
46194
46195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46196   void * jresult ;
46197   float arg1 ;
46198   float arg2 ;
46199   float arg3 ;
46200   float arg4 ;
46201   Dali::Rect< float > *result = 0 ;
46202
46203   arg1 = (float)jarg1;
46204   arg2 = (float)jarg2;
46205   arg3 = (float)jarg3;
46206   arg4 = (float)jarg4;
46207   {
46208     try {
46209       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46210     } catch (std::out_of_range& e) {
46211       {
46212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46213       };
46214     } catch (std::exception& e) {
46215       {
46216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46217       };
46218     } catch (...) {
46219       {
46220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46221       };
46222     }
46223   }
46224   jresult = (void *)result;
46225   return jresult;
46226 }
46227
46228
46229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46230   void * jresult ;
46231   Dali::Rect< float > *arg1 = 0 ;
46232   Dali::Rect< float > *result = 0 ;
46233
46234   arg1 = (Dali::Rect< float > *)jarg1;
46235   if (!arg1) {
46236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46237     return 0;
46238   }
46239   {
46240     try {
46241       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46242     } catch (std::out_of_range& e) {
46243       {
46244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46245       };
46246     } catch (std::exception& e) {
46247       {
46248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46249       };
46250     } catch (...) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46253       };
46254     }
46255   }
46256   jresult = (void *)result;
46257   return jresult;
46258 }
46259
46260
46261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46262   void * jresult ;
46263   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46264   Dali::Rect< float > *arg2 = 0 ;
46265   Dali::Rect< float > *result = 0 ;
46266
46267   arg1 = (Dali::Rect< float > *)jarg1;
46268   arg2 = (Dali::Rect< float > *)jarg2;
46269   if (!arg2) {
46270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46271     return 0;
46272   }
46273   {
46274     try {
46275       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46276     } catch (std::out_of_range& e) {
46277       {
46278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46279       };
46280     } catch (std::exception& e) {
46281       {
46282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46283       };
46284     } catch (...) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46287       };
46288     }
46289   }
46290   jresult = (void *)result;
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46296   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46297   float arg2 ;
46298   float arg3 ;
46299   float arg4 ;
46300   float arg5 ;
46301
46302   arg1 = (Dali::Rect< float > *)jarg1;
46303   arg2 = (float)jarg2;
46304   arg3 = (float)jarg3;
46305   arg4 = (float)jarg4;
46306   arg5 = (float)jarg5;
46307   {
46308     try {
46309       (arg1)->Set(arg2,arg3,arg4,arg5);
46310     } catch (std::out_of_range& e) {
46311       {
46312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46313       };
46314     } catch (std::exception& e) {
46315       {
46316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46317       };
46318     } catch (...) {
46319       {
46320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46321       };
46322     }
46323   }
46324 }
46325
46326
46327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46328   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46329   float arg2 ;
46330
46331   arg1 = (Dali::Rect< float > *)jarg1;
46332   arg2 = (float)jarg2;
46333   if (arg1) (arg1)->x = arg2;
46334 }
46335
46336
46337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46338   float jresult ;
46339   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46340   float result;
46341
46342   arg1 = (Dali::Rect< float > *)jarg1;
46343   result = (float) ((arg1)->x);
46344   jresult = result;
46345   return jresult;
46346 }
46347
46348
46349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46350   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46351   float arg2 ;
46352
46353   arg1 = (Dali::Rect< float > *)jarg1;
46354   arg2 = (float)jarg2;
46355   if (arg1) (arg1)->left = arg2;
46356 }
46357
46358
46359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46360   float jresult ;
46361   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46362   float result;
46363
46364   arg1 = (Dali::Rect< float > *)jarg1;
46365   result = (float) ((arg1)->left);
46366   jresult = result;
46367   return jresult;
46368 }
46369
46370
46371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46372   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46373   float arg2 ;
46374
46375   arg1 = (Dali::Rect< float > *)jarg1;
46376   arg2 = (float)jarg2;
46377   if (arg1) (arg1)->y = arg2;
46378 }
46379
46380
46381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46382   float jresult ;
46383   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46384   float result;
46385
46386   arg1 = (Dali::Rect< float > *)jarg1;
46387   result = (float) ((arg1)->y);
46388   jresult = result;
46389   return jresult;
46390 }
46391
46392
46393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46394   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46395   float arg2 ;
46396
46397   arg1 = (Dali::Rect< float > *)jarg1;
46398   arg2 = (float)jarg2;
46399   if (arg1) (arg1)->right = arg2;
46400 }
46401
46402
46403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46404   float jresult ;
46405   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46406   float result;
46407
46408   arg1 = (Dali::Rect< float > *)jarg1;
46409   result = (float) ((arg1)->right);
46410   jresult = result;
46411   return jresult;
46412 }
46413
46414
46415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46416   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46417   float arg2 ;
46418
46419   arg1 = (Dali::Rect< float > *)jarg1;
46420   arg2 = (float)jarg2;
46421   if (arg1) (arg1)->width = arg2;
46422 }
46423
46424
46425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46426   float jresult ;
46427   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46428   float result;
46429
46430   arg1 = (Dali::Rect< float > *)jarg1;
46431   result = (float) ((arg1)->width);
46432   jresult = result;
46433   return jresult;
46434 }
46435
46436
46437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46438   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46439   float arg2 ;
46440
46441   arg1 = (Dali::Rect< float > *)jarg1;
46442   arg2 = (float)jarg2;
46443   if (arg1) (arg1)->bottom = arg2;
46444 }
46445
46446
46447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46448   float jresult ;
46449   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46450   float result;
46451
46452   arg1 = (Dali::Rect< float > *)jarg1;
46453   result = (float) ((arg1)->bottom);
46454   jresult = result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46460   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46461   float arg2 ;
46462
46463   arg1 = (Dali::Rect< float > *)jarg1;
46464   arg2 = (float)jarg2;
46465   if (arg1) (arg1)->height = arg2;
46466 }
46467
46468
46469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46470   float jresult ;
46471   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46472   float result;
46473
46474   arg1 = (Dali::Rect< float > *)jarg1;
46475   result = (float) ((arg1)->height);
46476   jresult = result;
46477   return jresult;
46478 }
46479
46480
46481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46482   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46483   float arg2 ;
46484
46485   arg1 = (Dali::Rect< float > *)jarg1;
46486   arg2 = (float)jarg2;
46487   if (arg1) (arg1)->top = arg2;
46488 }
46489
46490
46491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46492   float jresult ;
46493   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46494   float result;
46495
46496   arg1 = (Dali::Rect< float > *)jarg1;
46497   result = (float) ((arg1)->top);
46498   jresult = result;
46499   return jresult;
46500 }
46501
46502
46503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46504   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46505
46506   arg1 = (Dali::Rect< float > *)jarg1;
46507   {
46508     try {
46509       delete arg1;
46510     } catch (std::out_of_range& e) {
46511       {
46512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46513       };
46514     } catch (std::exception& e) {
46515       {
46516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46517       };
46518     } catch (...) {
46519       {
46520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46521       };
46522     }
46523   }
46524 }
46525
46526
46527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46528   int jresult ;
46529   int result;
46530
46531   result = (int)Dali::Vector< int >::BaseType;
46532   jresult = (int)result;
46533   return jresult;
46534 }
46535
46536
46537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46538   void * jresult ;
46539   Dali::Vector< int > *result = 0 ;
46540
46541   {
46542     try {
46543       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46544     } catch (std::out_of_range& e) {
46545       {
46546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46547       };
46548     } catch (std::exception& e) {
46549       {
46550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46551       };
46552     } catch (...) {
46553       {
46554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46555       };
46556     }
46557   }
46558   jresult = (void *)result;
46559   return jresult;
46560 }
46561
46562
46563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46564   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46565
46566   arg1 = (Dali::Vector< int > *)jarg1;
46567   {
46568     try {
46569       delete arg1;
46570     } catch (std::out_of_range& e) {
46571       {
46572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46573       };
46574     } catch (std::exception& e) {
46575       {
46576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46577       };
46578     } catch (...) {
46579       {
46580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46581       };
46582     }
46583   }
46584 }
46585
46586
46587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46588   void * jresult ;
46589   Dali::Vector< int > *arg1 = 0 ;
46590   Dali::Vector< int > *result = 0 ;
46591
46592   arg1 = (Dali::Vector< int > *)jarg1;
46593   if (!arg1) {
46594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46595     return 0;
46596   }
46597   {
46598     try {
46599       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46600     } catch (std::out_of_range& e) {
46601       {
46602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46603       };
46604     } catch (std::exception& e) {
46605       {
46606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46607       };
46608     } catch (...) {
46609       {
46610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46611       };
46612     }
46613   }
46614   jresult = (void *)result;
46615   return jresult;
46616 }
46617
46618
46619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46620   void * jresult ;
46621   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46622   Dali::Vector< int > *arg2 = 0 ;
46623   Dali::Vector< int > *result = 0 ;
46624
46625   arg1 = (Dali::Vector< int > *)jarg1;
46626   arg2 = (Dali::Vector< int > *)jarg2;
46627   if (!arg2) {
46628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46629     return 0;
46630   }
46631   {
46632     try {
46633       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46634     } catch (std::out_of_range& e) {
46635       {
46636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46637       };
46638     } catch (std::exception& e) {
46639       {
46640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46641       };
46642     } catch (...) {
46643       {
46644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46645       };
46646     }
46647   }
46648   jresult = (void *)result;
46649   return jresult;
46650 }
46651
46652
46653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46654   void * jresult ;
46655   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46656   Dali::Vector< int >::Iterator result;
46657
46658   arg1 = (Dali::Vector< int > *)jarg1;
46659   {
46660     try {
46661       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46662     } catch (std::out_of_range& e) {
46663       {
46664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46665       };
46666     } catch (std::exception& e) {
46667       {
46668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46669       };
46670     } catch (...) {
46671       {
46672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46673       };
46674     }
46675   }
46676   jresult = (void *)result;
46677   return jresult;
46678 }
46679
46680
46681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46682   void * jresult ;
46683   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46684   Dali::Vector< int >::Iterator result;
46685
46686   arg1 = (Dali::Vector< int > *)jarg1;
46687   {
46688     try {
46689       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46690     } catch (std::out_of_range& e) {
46691       {
46692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46693       };
46694     } catch (std::exception& e) {
46695       {
46696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46697       };
46698     } catch (...) {
46699       {
46700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46701       };
46702     }
46703   }
46704   jresult = (void *)result;
46705   return jresult;
46706 }
46707
46708
46709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46710   void * jresult ;
46711   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46712   Dali::Vector< int >::SizeType arg2 ;
46713   Dali::Vector< int >::ItemType *result = 0 ;
46714
46715   arg1 = (Dali::Vector< int > *)jarg1;
46716   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46717   {
46718     try {
46719       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46720     } catch (std::out_of_range& e) {
46721       {
46722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46723       };
46724     } catch (std::exception& e) {
46725       {
46726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46727       };
46728     } catch (...) {
46729       {
46730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46731       };
46732     }
46733   }
46734   jresult = (void *)result;
46735   return jresult;
46736 }
46737
46738
46739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46740   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46741   Dali::Vector< int >::ItemType *arg2 = 0 ;
46742   Dali::Vector< int >::ItemType temp2 ;
46743
46744   arg1 = (Dali::Vector< int > *)jarg1;
46745   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46746   arg2 = &temp2;
46747   {
46748     try {
46749       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46750     } catch (std::out_of_range& e) {
46751       {
46752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46753       };
46754     } catch (std::exception& e) {
46755       {
46756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46757       };
46758     } catch (...) {
46759       {
46760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46761       };
46762     }
46763   }
46764 }
46765
46766
46767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46768   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46769   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46770   Dali::Vector< int >::ItemType *arg3 = 0 ;
46771   Dali::Vector< int >::ItemType temp3 ;
46772
46773   arg1 = (Dali::Vector< int > *)jarg1;
46774   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46775   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46776   arg3 = &temp3;
46777   {
46778     try {
46779       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46780     } catch (std::out_of_range& e) {
46781       {
46782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46783       };
46784     } catch (std::exception& e) {
46785       {
46786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46787       };
46788     } catch (...) {
46789       {
46790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46791       };
46792     }
46793   }
46794 }
46795
46796
46797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46798   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46799   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46800   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46801   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46802
46803   arg1 = (Dali::Vector< int > *)jarg1;
46804   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46805   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46806   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46807   {
46808     try {
46809       (arg1)->Insert(arg2,arg3,arg4);
46810     } catch (std::out_of_range& e) {
46811       {
46812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46813       };
46814     } catch (std::exception& e) {
46815       {
46816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46817       };
46818     } catch (...) {
46819       {
46820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46821       };
46822     }
46823   }
46824 }
46825
46826
46827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46828   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46829   Dali::Vector< int >::SizeType arg2 ;
46830
46831   arg1 = (Dali::Vector< int > *)jarg1;
46832   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46833   {
46834     try {
46835       (arg1)->Reserve(arg2);
46836     } catch (std::out_of_range& e) {
46837       {
46838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46839       };
46840     } catch (std::exception& e) {
46841       {
46842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46843       };
46844     } catch (...) {
46845       {
46846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46847       };
46848     }
46849   }
46850 }
46851
46852
46853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46854   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46855   Dali::Vector< int >::SizeType arg2 ;
46856
46857   arg1 = (Dali::Vector< int > *)jarg1;
46858   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46859   {
46860     try {
46861       (arg1)->Resize(arg2);
46862     } catch (std::out_of_range& e) {
46863       {
46864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46865       };
46866     } catch (std::exception& e) {
46867       {
46868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46869       };
46870     } catch (...) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46873       };
46874     }
46875   }
46876 }
46877
46878
46879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46880   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46881   Dali::Vector< int >::SizeType arg2 ;
46882   Dali::Vector< int >::ItemType *arg3 = 0 ;
46883   Dali::Vector< int >::ItemType temp3 ;
46884
46885   arg1 = (Dali::Vector< int > *)jarg1;
46886   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46887   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46888   arg3 = &temp3;
46889   {
46890     try {
46891       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46892     } catch (std::out_of_range& e) {
46893       {
46894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46895       };
46896     } catch (std::exception& e) {
46897       {
46898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46899       };
46900     } catch (...) {
46901       {
46902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46903       };
46904     }
46905   }
46906 }
46907
46908
46909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46910   void * jresult ;
46911   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46912   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46913   Dali::Vector< int >::Iterator result;
46914
46915   arg1 = (Dali::Vector< int > *)jarg1;
46916   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46917   {
46918     try {
46919       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46920     } catch (std::out_of_range& e) {
46921       {
46922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46923       };
46924     } catch (std::exception& e) {
46925       {
46926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46927       };
46928     } catch (...) {
46929       {
46930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46931       };
46932     }
46933   }
46934   jresult = (void *)result;
46935   return jresult;
46936 }
46937
46938
46939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46940   void * jresult ;
46941   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46942   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46943   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46944   Dali::Vector< int >::Iterator result;
46945
46946   arg1 = (Dali::Vector< int > *)jarg1;
46947   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46948   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46949   {
46950     try {
46951       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46952     } catch (std::out_of_range& e) {
46953       {
46954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46955       };
46956     } catch (std::exception& e) {
46957       {
46958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46959       };
46960     } catch (...) {
46961       {
46962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46963       };
46964     }
46965   }
46966   jresult = (void *)result;
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46972   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46973   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46974
46975   arg1 = (Dali::Vector< int > *)jarg1;
46976   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46977   {
46978     try {
46979       (arg1)->Remove(arg2);
46980     } catch (std::out_of_range& e) {
46981       {
46982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46983       };
46984     } catch (std::exception& e) {
46985       {
46986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46987       };
46988     } catch (...) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46991       };
46992     }
46993   }
46994 }
46995
46996
46997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46998   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46999   Dali::Vector< int > *arg2 = 0 ;
47000
47001   arg1 = (Dali::Vector< int > *)jarg1;
47002   arg2 = (Dali::Vector< int > *)jarg2;
47003   if (!arg2) {
47004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47005     return ;
47006   }
47007   {
47008     try {
47009       (arg1)->Swap(*arg2);
47010     } catch (std::out_of_range& e) {
47011       {
47012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47013       };
47014     } catch (std::exception& e) {
47015       {
47016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47017       };
47018     } catch (...) {
47019       {
47020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47021       };
47022     }
47023   }
47024 }
47025
47026
47027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47028   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47029
47030   arg1 = (Dali::Vector< int > *)jarg1;
47031   {
47032     try {
47033       (arg1)->Clear();
47034     } catch (std::out_of_range& e) {
47035       {
47036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47037       };
47038     } catch (std::exception& e) {
47039       {
47040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47041       };
47042     } catch (...) {
47043       {
47044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47045       };
47046     }
47047   }
47048 }
47049
47050
47051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47052   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47053
47054   arg1 = (Dali::Vector< int > *)jarg1;
47055   {
47056     try {
47057       (arg1)->Release();
47058     } catch (std::out_of_range& e) {
47059       {
47060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47061       };
47062     } catch (std::exception& e) {
47063       {
47064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47065       };
47066     } catch (...) {
47067       {
47068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47069       };
47070     }
47071   }
47072 }
47073
47074
47075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47076   int jresult ;
47077   int result;
47078
47079   result = (int)Dali::Vector< float >::BaseType;
47080   jresult = (int)result;
47081   return jresult;
47082 }
47083
47084
47085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47086   void * jresult ;
47087   Dali::Vector< float > *result = 0 ;
47088
47089   {
47090     try {
47091       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47092     } catch (std::out_of_range& e) {
47093       {
47094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47095       };
47096     } catch (std::exception& e) {
47097       {
47098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47099       };
47100     } catch (...) {
47101       {
47102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47103       };
47104     }
47105   }
47106   jresult = (void *)result;
47107   return jresult;
47108 }
47109
47110
47111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47112   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47113
47114   arg1 = (Dali::Vector< float > *)jarg1;
47115   {
47116     try {
47117       delete arg1;
47118     } catch (std::out_of_range& e) {
47119       {
47120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47121       };
47122     } catch (std::exception& e) {
47123       {
47124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47125       };
47126     } catch (...) {
47127       {
47128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47129       };
47130     }
47131   }
47132 }
47133
47134
47135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47136   void * jresult ;
47137   Dali::Vector< float > *arg1 = 0 ;
47138   Dali::Vector< float > *result = 0 ;
47139
47140   arg1 = (Dali::Vector< float > *)jarg1;
47141   if (!arg1) {
47142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47143     return 0;
47144   }
47145   {
47146     try {
47147       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47148     } catch (std::out_of_range& e) {
47149       {
47150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47151       };
47152     } catch (std::exception& e) {
47153       {
47154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47155       };
47156     } catch (...) {
47157       {
47158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47159       };
47160     }
47161   }
47162   jresult = (void *)result;
47163   return jresult;
47164 }
47165
47166
47167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47168   void * jresult ;
47169   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47170   Dali::Vector< float > *arg2 = 0 ;
47171   Dali::Vector< float > *result = 0 ;
47172
47173   arg1 = (Dali::Vector< float > *)jarg1;
47174   arg2 = (Dali::Vector< float > *)jarg2;
47175   if (!arg2) {
47176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47177     return 0;
47178   }
47179   {
47180     try {
47181       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47182     } catch (std::out_of_range& e) {
47183       {
47184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47185       };
47186     } catch (std::exception& e) {
47187       {
47188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47189       };
47190     } catch (...) {
47191       {
47192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47193       };
47194     }
47195   }
47196   jresult = (void *)result;
47197   return jresult;
47198 }
47199
47200
47201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47202   void * jresult ;
47203   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47204   Dali::Vector< float >::Iterator result;
47205
47206   arg1 = (Dali::Vector< float > *)jarg1;
47207   {
47208     try {
47209       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47210     } catch (std::out_of_range& e) {
47211       {
47212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47213       };
47214     } catch (std::exception& e) {
47215       {
47216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47217       };
47218     } catch (...) {
47219       {
47220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47221       };
47222     }
47223   }
47224   jresult = (void *)result;
47225   return jresult;
47226 }
47227
47228
47229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47230   void * jresult ;
47231   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47232   Dali::Vector< float >::Iterator result;
47233
47234   arg1 = (Dali::Vector< float > *)jarg1;
47235   {
47236     try {
47237       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47238     } catch (std::out_of_range& e) {
47239       {
47240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47241       };
47242     } catch (std::exception& e) {
47243       {
47244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (...) {
47247       {
47248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47249       };
47250     }
47251   }
47252   jresult = (void *)result;
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47258   void * jresult ;
47259   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47260   Dali::Vector< float >::SizeType arg2 ;
47261   Dali::Vector< float >::ItemType *result = 0 ;
47262
47263   arg1 = (Dali::Vector< float > *)jarg1;
47264   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47265   {
47266     try {
47267       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47268     } catch (std::out_of_range& e) {
47269       {
47270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47271       };
47272     } catch (std::exception& e) {
47273       {
47274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47275       };
47276     } catch (...) {
47277       {
47278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47279       };
47280     }
47281   }
47282   jresult = (void *)result;
47283   return jresult;
47284 }
47285
47286
47287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47288   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47289   Dali::Vector< float >::ItemType *arg2 = 0 ;
47290   Dali::Vector< float >::ItemType temp2 ;
47291
47292   arg1 = (Dali::Vector< float > *)jarg1;
47293   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47294   arg2 = &temp2;
47295   {
47296     try {
47297       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47298     } catch (std::out_of_range& e) {
47299       {
47300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47301       };
47302     } catch (std::exception& e) {
47303       {
47304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47305       };
47306     } catch (...) {
47307       {
47308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47309       };
47310     }
47311   }
47312 }
47313
47314
47315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47316   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47317   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47318   Dali::Vector< float >::ItemType *arg3 = 0 ;
47319   Dali::Vector< float >::ItemType temp3 ;
47320
47321   arg1 = (Dali::Vector< float > *)jarg1;
47322   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47323   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47324   arg3 = &temp3;
47325   {
47326     try {
47327       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47328     } catch (std::out_of_range& e) {
47329       {
47330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47331       };
47332     } catch (std::exception& e) {
47333       {
47334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47335       };
47336     } catch (...) {
47337       {
47338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47339       };
47340     }
47341   }
47342 }
47343
47344
47345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47346   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47347   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47348   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47349   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47350
47351   arg1 = (Dali::Vector< float > *)jarg1;
47352   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47353   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47354   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47355   {
47356     try {
47357       (arg1)->Insert(arg2,arg3,arg4);
47358     } catch (std::out_of_range& e) {
47359       {
47360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47361       };
47362     } catch (std::exception& e) {
47363       {
47364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47365       };
47366     } catch (...) {
47367       {
47368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47369       };
47370     }
47371   }
47372 }
47373
47374
47375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47376   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47377   Dali::Vector< float >::SizeType arg2 ;
47378
47379   arg1 = (Dali::Vector< float > *)jarg1;
47380   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47381   {
47382     try {
47383       (arg1)->Reserve(arg2);
47384     } catch (std::out_of_range& e) {
47385       {
47386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47387       };
47388     } catch (std::exception& e) {
47389       {
47390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47391       };
47392     } catch (...) {
47393       {
47394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47395       };
47396     }
47397   }
47398 }
47399
47400
47401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47402   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47403   Dali::Vector< float >::SizeType arg2 ;
47404
47405   arg1 = (Dali::Vector< float > *)jarg1;
47406   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47407   {
47408     try {
47409       (arg1)->Resize(arg2);
47410     } catch (std::out_of_range& e) {
47411       {
47412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47413       };
47414     } catch (std::exception& e) {
47415       {
47416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47417       };
47418     } catch (...) {
47419       {
47420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47421       };
47422     }
47423   }
47424 }
47425
47426
47427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47428   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47429   Dali::Vector< float >::SizeType arg2 ;
47430   Dali::Vector< float >::ItemType *arg3 = 0 ;
47431   Dali::Vector< float >::ItemType temp3 ;
47432
47433   arg1 = (Dali::Vector< float > *)jarg1;
47434   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47435   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47436   arg3 = &temp3;
47437   {
47438     try {
47439       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47440     } catch (std::out_of_range& e) {
47441       {
47442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47443       };
47444     } catch (std::exception& e) {
47445       {
47446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47447       };
47448     } catch (...) {
47449       {
47450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47451       };
47452     }
47453   }
47454 }
47455
47456
47457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47458   void * jresult ;
47459   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47460   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47461   Dali::Vector< float >::Iterator result;
47462
47463   arg1 = (Dali::Vector< float > *)jarg1;
47464   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47465   {
47466     try {
47467       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47468     } catch (std::out_of_range& e) {
47469       {
47470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47471       };
47472     } catch (std::exception& e) {
47473       {
47474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47475       };
47476     } catch (...) {
47477       {
47478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47479       };
47480     }
47481   }
47482   jresult = (void *)result;
47483   return jresult;
47484 }
47485
47486
47487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47488   void * jresult ;
47489   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47490   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47491   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47492   Dali::Vector< float >::Iterator result;
47493
47494   arg1 = (Dali::Vector< float > *)jarg1;
47495   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47496   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47497   {
47498     try {
47499       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47500     } catch (std::out_of_range& e) {
47501       {
47502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47503       };
47504     } catch (std::exception& e) {
47505       {
47506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47507       };
47508     } catch (...) {
47509       {
47510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47511       };
47512     }
47513   }
47514   jresult = (void *)result;
47515   return jresult;
47516 }
47517
47518
47519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47520   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47521   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47522
47523   arg1 = (Dali::Vector< float > *)jarg1;
47524   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47525   {
47526     try {
47527       (arg1)->Remove(arg2);
47528     } catch (std::out_of_range& e) {
47529       {
47530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47531       };
47532     } catch (std::exception& e) {
47533       {
47534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47535       };
47536     } catch (...) {
47537       {
47538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47539       };
47540     }
47541   }
47542 }
47543
47544
47545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47546   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47547   Dali::Vector< float > *arg2 = 0 ;
47548
47549   arg1 = (Dali::Vector< float > *)jarg1;
47550   arg2 = (Dali::Vector< float > *)jarg2;
47551   if (!arg2) {
47552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47553     return ;
47554   }
47555   {
47556     try {
47557       (arg1)->Swap(*arg2);
47558     } catch (std::out_of_range& e) {
47559       {
47560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47561       };
47562     } catch (std::exception& e) {
47563       {
47564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47565       };
47566     } catch (...) {
47567       {
47568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47569       };
47570     }
47571   }
47572 }
47573
47574
47575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47576   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47577
47578   arg1 = (Dali::Vector< float > *)jarg1;
47579   {
47580     try {
47581       (arg1)->Clear();
47582     } catch (std::out_of_range& e) {
47583       {
47584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47585       };
47586     } catch (std::exception& e) {
47587       {
47588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47589       };
47590     } catch (...) {
47591       {
47592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47593       };
47594     }
47595   }
47596 }
47597
47598
47599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47600   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47601
47602   arg1 = (Dali::Vector< float > *)jarg1;
47603   {
47604     try {
47605       (arg1)->Release();
47606     } catch (std::out_of_range& e) {
47607       {
47608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47609       };
47610     } catch (std::exception& e) {
47611       {
47612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47613       };
47614     } catch (...) {
47615       {
47616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47617       };
47618     }
47619   }
47620 }
47621
47622
47623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47624   int jresult ;
47625   int result;
47626
47627   result = (int)Dali::Vector< unsigned char >::BaseType;
47628   jresult = (int)result;
47629   return jresult;
47630 }
47631
47632
47633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47634   void * jresult ;
47635   Dali::Vector< unsigned char > *result = 0 ;
47636
47637   {
47638     try {
47639       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47640     } catch (std::out_of_range& e) {
47641       {
47642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47643       };
47644     } catch (std::exception& e) {
47645       {
47646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47647       };
47648     } catch (...) {
47649       {
47650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47651       };
47652     }
47653   }
47654   jresult = (void *)result;
47655   return jresult;
47656 }
47657
47658
47659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47660   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47661
47662   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47663   {
47664     try {
47665       delete arg1;
47666     } catch (std::out_of_range& e) {
47667       {
47668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47669       };
47670     } catch (std::exception& e) {
47671       {
47672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47673       };
47674     } catch (...) {
47675       {
47676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47677       };
47678     }
47679   }
47680 }
47681
47682
47683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47684   void * jresult ;
47685   Dali::Vector< unsigned char > *arg1 = 0 ;
47686   Dali::Vector< unsigned char > *result = 0 ;
47687
47688   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47689   if (!arg1) {
47690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47691     return 0;
47692   }
47693   {
47694     try {
47695       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47696     } catch (std::out_of_range& e) {
47697       {
47698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47699       };
47700     } catch (std::exception& e) {
47701       {
47702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47703       };
47704     } catch (...) {
47705       {
47706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47707       };
47708     }
47709   }
47710   jresult = (void *)result;
47711   return jresult;
47712 }
47713
47714
47715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47716   void * jresult ;
47717   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47718   Dali::Vector< unsigned char > *arg2 = 0 ;
47719   Dali::Vector< unsigned char > *result = 0 ;
47720
47721   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47722   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47723   if (!arg2) {
47724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47725     return 0;
47726   }
47727   {
47728     try {
47729       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47730     } catch (std::out_of_range& e) {
47731       {
47732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47733       };
47734     } catch (std::exception& e) {
47735       {
47736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (...) {
47739       {
47740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47741       };
47742     }
47743   }
47744   jresult = (void *)result;
47745   return jresult;
47746 }
47747
47748
47749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47750   void * jresult ;
47751   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47752   Dali::Vector< unsigned char >::Iterator result;
47753
47754   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47755   {
47756     try {
47757       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47758     } catch (std::out_of_range& e) {
47759       {
47760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47761       };
47762     } catch (std::exception& e) {
47763       {
47764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47765       };
47766     } catch (...) {
47767       {
47768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47769       };
47770     }
47771   }
47772   jresult = (void *)result;
47773   return jresult;
47774 }
47775
47776
47777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47778   void * jresult ;
47779   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47780   Dali::Vector< unsigned char >::Iterator result;
47781
47782   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47783   {
47784     try {
47785       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47786     } catch (std::out_of_range& e) {
47787       {
47788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47789       };
47790     } catch (std::exception& e) {
47791       {
47792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47793       };
47794     } catch (...) {
47795       {
47796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47797       };
47798     }
47799   }
47800   jresult = (void *)result;
47801   return jresult;
47802 }
47803
47804
47805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47806   void * jresult ;
47807   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47808   Dali::Vector< unsigned char >::SizeType arg2 ;
47809   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47810
47811   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47812   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47813   {
47814     try {
47815       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47816     } catch (std::out_of_range& e) {
47817       {
47818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47819       };
47820     } catch (std::exception& e) {
47821       {
47822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47823       };
47824     } catch (...) {
47825       {
47826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47827       };
47828     }
47829   }
47830   jresult = (void *)result;
47831   return jresult;
47832 }
47833
47834
47835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47836   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47837   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47838   Dali::Vector< unsigned char >::ItemType temp2 ;
47839
47840   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47841   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47842   arg2 = &temp2;
47843   {
47844     try {
47845       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47846     } catch (std::out_of_range& e) {
47847       {
47848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47849       };
47850     } catch (std::exception& e) {
47851       {
47852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47853       };
47854     } catch (...) {
47855       {
47856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47857       };
47858     }
47859   }
47860 }
47861
47862
47863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47864   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47865   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47866   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47867   Dali::Vector< unsigned char >::ItemType temp3 ;
47868
47869   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47870   arg2 = jarg2;
47871   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47872   arg3 = &temp3;
47873   {
47874     try {
47875       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47876     } catch (std::out_of_range& e) {
47877       {
47878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47879       };
47880     } catch (std::exception& e) {
47881       {
47882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47883       };
47884     } catch (...) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47887       };
47888     }
47889   }
47890
47891
47892 }
47893
47894
47895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47896   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47897   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47898   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47899   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47900
47901   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47902   arg2 = jarg2;
47903   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47904   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47905   {
47906     try {
47907       (arg1)->Insert(arg2,arg3,arg4);
47908     } catch (std::out_of_range& e) {
47909       {
47910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47911       };
47912     } catch (std::exception& e) {
47913       {
47914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47915       };
47916     } catch (...) {
47917       {
47918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47919       };
47920     }
47921   }
47922
47923
47924 }
47925
47926
47927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47928   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47929   Dali::Vector< unsigned char >::SizeType arg2 ;
47930
47931   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47932   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47933   {
47934     try {
47935       (arg1)->Reserve(arg2);
47936     } catch (std::out_of_range& e) {
47937       {
47938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47939       };
47940     } catch (std::exception& e) {
47941       {
47942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47943       };
47944     } catch (...) {
47945       {
47946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47947       };
47948     }
47949   }
47950 }
47951
47952
47953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47954   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47955   Dali::Vector< unsigned char >::SizeType arg2 ;
47956
47957   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47958   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47959   {
47960     try {
47961       (arg1)->Resize(arg2);
47962     } catch (std::out_of_range& e) {
47963       {
47964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47965       };
47966     } catch (std::exception& e) {
47967       {
47968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47969       };
47970     } catch (...) {
47971       {
47972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47973       };
47974     }
47975   }
47976 }
47977
47978
47979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47980   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47981   Dali::Vector< unsigned char >::SizeType arg2 ;
47982   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47983   Dali::Vector< unsigned char >::ItemType temp3 ;
47984
47985   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47986   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47987   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47988   arg3 = &temp3;
47989   {
47990     try {
47991       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47992     } catch (std::out_of_range& e) {
47993       {
47994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47995       };
47996     } catch (std::exception& e) {
47997       {
47998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47999       };
48000     } catch (...) {
48001       {
48002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48003       };
48004     }
48005   }
48006 }
48007
48008
48009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48010   void * jresult ;
48011   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48012   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48013   Dali::Vector< unsigned char >::Iterator result;
48014
48015   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48016   arg2 = jarg2;
48017   {
48018     try {
48019       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48020     } catch (std::out_of_range& e) {
48021       {
48022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48023       };
48024     } catch (std::exception& e) {
48025       {
48026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48027       };
48028     } catch (...) {
48029       {
48030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48031       };
48032     }
48033   }
48034   jresult = (void *)result;
48035
48036
48037   return jresult;
48038 }
48039
48040
48041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48042   void * jresult ;
48043   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48044   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48045   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48046   Dali::Vector< unsigned char >::Iterator result;
48047
48048   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48049   arg2 = jarg2;
48050   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48051   {
48052     try {
48053       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48054     } catch (std::out_of_range& e) {
48055       {
48056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48057       };
48058     } catch (std::exception& e) {
48059       {
48060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48061       };
48062     } catch (...) {
48063       {
48064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48065       };
48066     }
48067   }
48068   jresult = (void *)result;
48069
48070
48071   return jresult;
48072 }
48073
48074
48075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48076   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48077   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48078
48079   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48080   arg2 = jarg2;
48081   {
48082     try {
48083       (arg1)->Remove(arg2);
48084     } catch (std::out_of_range& e) {
48085       {
48086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48087       };
48088     } catch (std::exception& e) {
48089       {
48090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48091       };
48092     } catch (...) {
48093       {
48094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48095       };
48096     }
48097   }
48098
48099
48100 }
48101
48102
48103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48104   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48105   Dali::Vector< unsigned char > *arg2 = 0 ;
48106
48107   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48108   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48109   if (!arg2) {
48110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48111     return ;
48112   }
48113   {
48114     try {
48115       (arg1)->Swap(*arg2);
48116     } catch (std::out_of_range& e) {
48117       {
48118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48119       };
48120     } catch (std::exception& e) {
48121       {
48122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48123       };
48124     } catch (...) {
48125       {
48126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48127       };
48128     }
48129   }
48130 }
48131
48132
48133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48134   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48135
48136   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48137   {
48138     try {
48139       (arg1)->Clear();
48140     } catch (std::out_of_range& e) {
48141       {
48142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48143       };
48144     } catch (std::exception& e) {
48145       {
48146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48147       };
48148     } catch (...) {
48149       {
48150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48151       };
48152     }
48153   }
48154 }
48155
48156
48157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48158   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48159
48160   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48161   {
48162     try {
48163       (arg1)->Release();
48164     } catch (std::out_of_range& e) {
48165       {
48166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48167       };
48168     } catch (std::exception& e) {
48169       {
48170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48171       };
48172     } catch (...) {
48173       {
48174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48175       };
48176     }
48177   }
48178 }
48179
48180
48181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48182   int jresult ;
48183   int result;
48184
48185   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48186   jresult = (int)result;
48187   return jresult;
48188 }
48189
48190
48191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48192   void * jresult ;
48193   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48194
48195   {
48196     try {
48197       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48198     } catch (std::out_of_range& e) {
48199       {
48200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48201       };
48202     } catch (std::exception& e) {
48203       {
48204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48205       };
48206     } catch (...) {
48207       {
48208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48209       };
48210     }
48211   }
48212   jresult = (void *)result;
48213   return jresult;
48214 }
48215
48216
48217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48218   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48219
48220   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48221   {
48222     try {
48223       delete arg1;
48224     } catch (std::out_of_range& e) {
48225       {
48226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48227       };
48228     } catch (std::exception& e) {
48229       {
48230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48231       };
48232     } catch (...) {
48233       {
48234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48235       };
48236     }
48237   }
48238 }
48239
48240
48241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48242   void * jresult ;
48243   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48244   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48245
48246   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48247   if (!arg1) {
48248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48249     return 0;
48250   }
48251   {
48252     try {
48253       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48254     } catch (std::out_of_range& e) {
48255       {
48256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48257       };
48258     } catch (std::exception& e) {
48259       {
48260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48261       };
48262     } catch (...) {
48263       {
48264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48265       };
48266     }
48267   }
48268   jresult = (void *)result;
48269   return jresult;
48270 }
48271
48272
48273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48274   void * jresult ;
48275   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48276   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48277   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48278
48279   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48280   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48281   if (!arg2) {
48282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48283     return 0;
48284   }
48285   {
48286     try {
48287       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48288     } catch (std::out_of_range& e) {
48289       {
48290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48291       };
48292     } catch (std::exception& e) {
48293       {
48294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48295       };
48296     } catch (...) {
48297       {
48298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48299       };
48300     }
48301   }
48302   jresult = (void *)result;
48303   return jresult;
48304 }
48305
48306
48307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48308   void * jresult ;
48309   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48310   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48311
48312   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48313   {
48314     try {
48315       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48316     } catch (std::out_of_range& e) {
48317       {
48318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48319       };
48320     } catch (std::exception& e) {
48321       {
48322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48323       };
48324     } catch (...) {
48325       {
48326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48327       };
48328     }
48329   }
48330   jresult = (void *)result;
48331   return jresult;
48332 }
48333
48334
48335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48336   void * jresult ;
48337   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48338   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48339
48340   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48341   {
48342     try {
48343       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48344     } catch (std::out_of_range& e) {
48345       {
48346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48347       };
48348     } catch (std::exception& e) {
48349       {
48350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48351       };
48352     } catch (...) {
48353       {
48354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48355       };
48356     }
48357   }
48358   jresult = (void *)result;
48359   return jresult;
48360 }
48361
48362
48363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48364   void * jresult ;
48365   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48366   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48367   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48368
48369   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48370   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48371   {
48372     try {
48373       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48374     } catch (std::out_of_range& e) {
48375       {
48376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48377       };
48378     } catch (std::exception& e) {
48379       {
48380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48381       };
48382     } catch (...) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48385       };
48386     }
48387   }
48388   jresult = (void *)result;
48389   return jresult;
48390 }
48391
48392
48393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48394   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48395   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48396
48397   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48398   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48399   if (!arg2) {
48400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48401     return ;
48402   }
48403   {
48404     try {
48405       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48406     } catch (std::out_of_range& e) {
48407       {
48408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48409       };
48410     } catch (std::exception& e) {
48411       {
48412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48413       };
48414     } catch (...) {
48415       {
48416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48417       };
48418     }
48419   }
48420 }
48421
48422
48423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48424   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48425   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48426   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48427
48428   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48429   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48430   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48431   if (!arg3) {
48432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48433     return ;
48434   }
48435   {
48436     try {
48437       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48438     } catch (std::out_of_range& e) {
48439       {
48440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48441       };
48442     } catch (std::exception& e) {
48443       {
48444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48445       };
48446     } catch (...) {
48447       {
48448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48449       };
48450     }
48451   }
48452 }
48453
48454
48455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48456   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48457   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48458   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48459   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48460
48461   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48462   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48463   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48464   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48465   {
48466     try {
48467       (arg1)->Insert(arg2,arg3,arg4);
48468     } catch (std::out_of_range& e) {
48469       {
48470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48471       };
48472     } catch (std::exception& e) {
48473       {
48474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48475       };
48476     } catch (...) {
48477       {
48478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48479       };
48480     }
48481   }
48482 }
48483
48484
48485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48486   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48487   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48488
48489   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48490   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48491   {
48492     try {
48493       (arg1)->Reserve(arg2);
48494     } catch (std::out_of_range& e) {
48495       {
48496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48497       };
48498     } catch (std::exception& e) {
48499       {
48500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48501       };
48502     } catch (...) {
48503       {
48504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48505       };
48506     }
48507   }
48508 }
48509
48510
48511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48512   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48513   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48514
48515   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48516   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48517   {
48518     try {
48519       (arg1)->Resize(arg2);
48520     } catch (std::out_of_range& e) {
48521       {
48522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48523       };
48524     } catch (std::exception& e) {
48525       {
48526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48527       };
48528     } catch (...) {
48529       {
48530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48531       };
48532     }
48533   }
48534 }
48535
48536
48537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48538   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48539   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48540   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48541
48542   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48543   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48544   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48545   if (!arg3) {
48546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48547     return ;
48548   }
48549   {
48550     try {
48551       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48552     } catch (std::out_of_range& e) {
48553       {
48554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (std::exception& e) {
48557       {
48558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48563       };
48564     }
48565   }
48566 }
48567
48568
48569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48570   void * jresult ;
48571   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48572   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48573   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48574
48575   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48576   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48577   {
48578     try {
48579       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48580     } catch (std::out_of_range& e) {
48581       {
48582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48583       };
48584     } catch (std::exception& e) {
48585       {
48586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48587       };
48588     } catch (...) {
48589       {
48590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48591       };
48592     }
48593   }
48594   jresult = (void *)result;
48595   return jresult;
48596 }
48597
48598
48599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48600   void * jresult ;
48601   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48602   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48603   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48604   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48605
48606   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48607   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48608   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48609   {
48610     try {
48611       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48612     } catch (std::out_of_range& e) {
48613       {
48614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48615       };
48616     } catch (std::exception& e) {
48617       {
48618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (...) {
48621       {
48622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48623       };
48624     }
48625   }
48626   jresult = (void *)result;
48627   return jresult;
48628 }
48629
48630
48631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48632   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48633   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48634
48635   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48636   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48637   {
48638     try {
48639       (arg1)->Remove(arg2);
48640     } catch (std::out_of_range& e) {
48641       {
48642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48643       };
48644     } catch (std::exception& e) {
48645       {
48646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (...) {
48649       {
48650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48651       };
48652     }
48653   }
48654 }
48655
48656
48657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48658   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48659   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48660
48661   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48662   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48663   if (!arg2) {
48664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48665     return ;
48666   }
48667   {
48668     try {
48669       (arg1)->Swap(*arg2);
48670     } catch (std::out_of_range& e) {
48671       {
48672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48673       };
48674     } catch (std::exception& e) {
48675       {
48676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48677       };
48678     } catch (...) {
48679       {
48680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48681       };
48682     }
48683   }
48684 }
48685
48686
48687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48688   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48689
48690   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48691   {
48692     try {
48693       (arg1)->Clear();
48694     } catch (std::out_of_range& e) {
48695       {
48696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48697       };
48698     } catch (std::exception& e) {
48699       {
48700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48701       };
48702     } catch (...) {
48703       {
48704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48705       };
48706     }
48707   }
48708 }
48709
48710
48711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48712   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48713
48714   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48715   {
48716     try {
48717       (arg1)->Release();
48718     } catch (std::out_of_range& e) {
48719       {
48720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48721       };
48722     } catch (std::exception& e) {
48723       {
48724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48725       };
48726     } catch (...) {
48727       {
48728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48729       };
48730     }
48731   }
48732 }
48733
48734
48735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48736   void * jresult ;
48737   Dali::Signal< void () > *result = 0 ;
48738
48739   {
48740     try {
48741       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48742     } catch (std::out_of_range& e) {
48743       {
48744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48745       };
48746     } catch (std::exception& e) {
48747       {
48748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48749       };
48750     } catch (...) {
48751       {
48752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48753       };
48754     }
48755   }
48756   jresult = (void *)result;
48757   return jresult;
48758 }
48759
48760
48761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48762   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48763
48764   arg1 = (Dali::Signal< void () > *)jarg1;
48765   {
48766     try {
48767       delete arg1;
48768     } catch (std::out_of_range& e) {
48769       {
48770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48771       };
48772     } catch (std::exception& e) {
48773       {
48774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (...) {
48777       {
48778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48779       };
48780     }
48781   }
48782 }
48783
48784
48785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48786   unsigned int jresult ;
48787   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48788   bool result;
48789
48790   arg1 = (Dali::Signal< void () > *)jarg1;
48791   {
48792     try {
48793       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48794     } catch (std::out_of_range& e) {
48795       {
48796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48797       };
48798     } catch (std::exception& e) {
48799       {
48800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48801       };
48802     } catch (...) {
48803       {
48804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48805       };
48806     }
48807   }
48808   jresult = result;
48809   return jresult;
48810 }
48811
48812
48813 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48814   unsigned long jresult ;
48815   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48816   std::size_t result;
48817
48818   arg1 = (Dali::Signal< void () > *)jarg1;
48819   {
48820     try {
48821       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48822     } catch (std::out_of_range& e) {
48823       {
48824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48825       };
48826     } catch (std::exception& e) {
48827       {
48828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48829       };
48830     } catch (...) {
48831       {
48832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48833       };
48834     }
48835   }
48836   jresult = (unsigned long)result;
48837   return jresult;
48838 }
48839
48840
48841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48842   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48843   void (*arg2)() = (void (*)()) 0 ;
48844
48845   arg1 = (Dali::Signal< void () > *)jarg1;
48846   arg2 = (void (*)())jarg2;
48847   {
48848     try {
48849       (arg1)->Connect(arg2);
48850     } catch (std::out_of_range& e) {
48851       {
48852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48853       };
48854     } catch (std::exception& e) {
48855       {
48856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48857       };
48858     } catch (...) {
48859       {
48860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48861       };
48862     }
48863   }
48864 }
48865
48866
48867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48868   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48869   void (*arg2)() = (void (*)()) 0 ;
48870
48871   arg1 = (Dali::Signal< void () > *)jarg1;
48872   arg2 = (void (*)())jarg2;
48873   {
48874     try {
48875       (arg1)->Disconnect(arg2);
48876     } catch (std::out_of_range& e) {
48877       {
48878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48879       };
48880     } catch (std::exception& e) {
48881       {
48882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48883       };
48884     } catch (...) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48887       };
48888     }
48889   }
48890 }
48891
48892
48893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48894   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48895   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48896   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48897
48898   arg1 = (Dali::Signal< void () > *)jarg1;
48899   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48900   arg3 = (Dali::FunctorDelegate *)jarg3;
48901   {
48902     try {
48903       (arg1)->Connect(arg2,arg3);
48904     } catch (std::out_of_range& e) {
48905       {
48906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48907       };
48908     } catch (std::exception& e) {
48909       {
48910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48911       };
48912     } catch (...) {
48913       {
48914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48915       };
48916     }
48917   }
48918 }
48919
48920
48921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48922   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48923
48924   arg1 = (Dali::Signal< void () > *)jarg1;
48925   {
48926     try {
48927       (arg1)->Emit();
48928     } catch (std::out_of_range& e) {
48929       {
48930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48931       };
48932     } catch (std::exception& e) {
48933       {
48934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48935       };
48936     } catch (...) {
48937       {
48938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48939       };
48940     }
48941   }
48942 }
48943
48944
48945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48946   unsigned int jresult ;
48947   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48948   bool result;
48949
48950   arg1 = (Dali::Signal< void (float) > *)jarg1;
48951   {
48952     try {
48953       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48954     } catch (std::out_of_range& e) {
48955       {
48956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48957       };
48958     } catch (std::exception& e) {
48959       {
48960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48961       };
48962     } catch (...) {
48963       {
48964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48965       };
48966     }
48967   }
48968   jresult = result;
48969   return jresult;
48970 }
48971
48972
48973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48974   unsigned long jresult ;
48975   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48976   std::size_t result;
48977
48978   arg1 = (Dali::Signal< void (float) > *)jarg1;
48979   {
48980     try {
48981       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48982     } catch (std::out_of_range& e) {
48983       {
48984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48985       };
48986     } catch (std::exception& e) {
48987       {
48988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48989       };
48990     } catch (...) {
48991       {
48992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48993       };
48994     }
48995   }
48996   jresult = (unsigned long)result;
48997   return jresult;
48998 }
48999
49000
49001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49002   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49003   void (*arg2)(float) = (void (*)(float)) 0 ;
49004
49005   arg1 = (Dali::Signal< void (float) > *)jarg1;
49006   arg2 = (void (*)(float))jarg2;
49007   {
49008     try {
49009       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49010     } catch (std::out_of_range& e) {
49011       {
49012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49013       };
49014     } catch (std::exception& e) {
49015       {
49016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49017       };
49018     } catch (...) {
49019       {
49020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49021       };
49022     }
49023   }
49024 }
49025
49026
49027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49028   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49029   void (*arg2)(float) = (void (*)(float)) 0 ;
49030
49031   arg1 = (Dali::Signal< void (float) > *)jarg1;
49032   arg2 = (void (*)(float))jarg2;
49033   {
49034     try {
49035       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49036     } catch (std::out_of_range& e) {
49037       {
49038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49039       };
49040     } catch (std::exception& e) {
49041       {
49042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49043       };
49044     } catch (...) {
49045       {
49046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49047       };
49048     }
49049   }
49050 }
49051
49052
49053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49054   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49055   float arg2 ;
49056
49057   arg1 = (Dali::Signal< void (float) > *)jarg1;
49058   arg2 = (float)jarg2;
49059   {
49060     try {
49061       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49062     } catch (std::out_of_range& e) {
49063       {
49064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49065       };
49066     } catch (std::exception& e) {
49067       {
49068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49069       };
49070     } catch (...) {
49071       {
49072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49073       };
49074     }
49075   }
49076 }
49077
49078
49079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49080   void * jresult ;
49081   Dali::Signal< void (float) > *result = 0 ;
49082
49083   {
49084     try {
49085       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49086     } catch (std::out_of_range& e) {
49087       {
49088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49089       };
49090     } catch (std::exception& e) {
49091       {
49092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49093       };
49094     } catch (...) {
49095       {
49096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49097       };
49098     }
49099   }
49100   jresult = (void *)result;
49101   return jresult;
49102 }
49103
49104
49105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49106   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49107
49108   arg1 = (Dali::Signal< void (float) > *)jarg1;
49109   {
49110     try {
49111       delete arg1;
49112     } catch (std::out_of_range& e) {
49113       {
49114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49115       };
49116     } catch (std::exception& e) {
49117       {
49118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49119       };
49120     } catch (...) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49123       };
49124     }
49125   }
49126 }
49127
49128
49129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49130   unsigned int jresult ;
49131   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49132   bool result;
49133
49134   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49135   {
49136     try {
49137       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49138     } catch (std::out_of_range& e) {
49139       {
49140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49141       };
49142     } catch (std::exception& e) {
49143       {
49144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49145       };
49146     } catch (...) {
49147       {
49148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49149       };
49150     }
49151   }
49152   jresult = result;
49153   return jresult;
49154 }
49155
49156
49157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49158   unsigned long jresult ;
49159   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49160   std::size_t result;
49161
49162   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49163   {
49164     try {
49165       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49166     } catch (std::out_of_range& e) {
49167       {
49168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49169       };
49170     } catch (std::exception& e) {
49171       {
49172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49173       };
49174     } catch (...) {
49175       {
49176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49177       };
49178     }
49179   }
49180   jresult = (unsigned long)result;
49181   return jresult;
49182 }
49183
49184
49185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49186   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49187   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49188
49189   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49190   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49191   {
49192     try {
49193       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49194     } catch (std::out_of_range& e) {
49195       {
49196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49197       };
49198     } catch (std::exception& e) {
49199       {
49200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49201       };
49202     } catch (...) {
49203       {
49204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49205       };
49206     }
49207   }
49208 }
49209
49210
49211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49212   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49213   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49214
49215   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49216   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49217   {
49218     try {
49219       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49220     } catch (std::out_of_range& e) {
49221       {
49222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49223       };
49224     } catch (std::exception& e) {
49225       {
49226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49227       };
49228     } catch (...) {
49229       {
49230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49231       };
49232     }
49233   }
49234 }
49235
49236
49237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49238   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49239   Dali::BaseHandle arg2 ;
49240   Dali::BaseHandle *argp2 ;
49241
49242   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49243   argp2 = (Dali::BaseHandle *)jarg2;
49244   if (!argp2) {
49245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49246     return ;
49247   }
49248   arg2 = *argp2;
49249   {
49250     try {
49251       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49252     } catch (std::out_of_range& e) {
49253       {
49254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49255       };
49256     } catch (std::exception& e) {
49257       {
49258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49259       };
49260     } catch (...) {
49261       {
49262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49263       };
49264     }
49265   }
49266 }
49267
49268
49269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49270   void * jresult ;
49271   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49272
49273   {
49274     try {
49275       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49276     } catch (std::out_of_range& e) {
49277       {
49278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49279       };
49280     } catch (std::exception& e) {
49281       {
49282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49283       };
49284     } catch (...) {
49285       {
49286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49287       };
49288     }
49289   }
49290   jresult = (void *)result;
49291   return jresult;
49292 }
49293
49294
49295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49296   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49297
49298   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49299   {
49300     try {
49301       delete arg1;
49302     } catch (std::out_of_range& e) {
49303       {
49304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49305       };
49306     } catch (std::exception& e) {
49307       {
49308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (...) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49313       };
49314     }
49315   }
49316 }
49317
49318
49319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49320   unsigned int jresult ;
49321   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49322   bool result;
49323
49324   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49325   {
49326     try {
49327       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49328     } catch (std::out_of_range& e) {
49329       {
49330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49331       };
49332     } catch (std::exception& e) {
49333       {
49334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49335       };
49336     } catch (...) {
49337       {
49338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49339       };
49340     }
49341   }
49342   jresult = result;
49343   return jresult;
49344 }
49345
49346
49347 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49348   unsigned long jresult ;
49349   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49350   std::size_t result;
49351
49352   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49353   {
49354     try {
49355       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49356     } catch (std::out_of_range& e) {
49357       {
49358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49359       };
49360     } catch (std::exception& e) {
49361       {
49362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49363       };
49364     } catch (...) {
49365       {
49366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49367       };
49368     }
49369   }
49370   jresult = (unsigned long)result;
49371   return jresult;
49372 }
49373
49374
49375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49376   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49377   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49378
49379   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49380   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49381   {
49382     try {
49383       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49384     } catch (std::out_of_range& e) {
49385       {
49386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49387       };
49388     } catch (std::exception& e) {
49389       {
49390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49391       };
49392     } catch (...) {
49393       {
49394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49395       };
49396     }
49397   }
49398 }
49399
49400
49401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49402   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49403   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49404
49405   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49406   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49407   {
49408     try {
49409       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49410     } catch (std::out_of_range& e) {
49411       {
49412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49413       };
49414     } catch (std::exception& e) {
49415       {
49416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49417       };
49418     } catch (...) {
49419       {
49420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49421       };
49422     }
49423   }
49424 }
49425
49426
49427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49428   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49429   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49430
49431   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49432   arg2 = (Dali::RefObject *)jarg2;
49433   {
49434     try {
49435       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49436     } catch (std::out_of_range& e) {
49437       {
49438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49439       };
49440     } catch (std::exception& e) {
49441       {
49442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49443       };
49444     } catch (...) {
49445       {
49446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49447       };
49448     }
49449   }
49450 }
49451
49452
49453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49454   void * jresult ;
49455   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49456
49457   {
49458     try {
49459       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49460     } catch (std::out_of_range& e) {
49461       {
49462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49463       };
49464     } catch (std::exception& e) {
49465       {
49466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49467       };
49468     } catch (...) {
49469       {
49470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49471       };
49472     }
49473   }
49474   jresult = (void *)result;
49475   return jresult;
49476 }
49477
49478
49479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49480   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49481
49482   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49483   {
49484     try {
49485       delete arg1;
49486     } catch (std::out_of_range& e) {
49487       {
49488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49489       };
49490     } catch (std::exception& e) {
49491       {
49492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49493       };
49494     } catch (...) {
49495       {
49496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49497       };
49498     }
49499   }
49500 }
49501
49502
49503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49504   unsigned int jresult ;
49505   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49506   bool result;
49507
49508   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49509   {
49510     try {
49511       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49512     } catch (std::out_of_range& e) {
49513       {
49514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49515       };
49516     } catch (std::exception& e) {
49517       {
49518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49519       };
49520     } catch (...) {
49521       {
49522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49523       };
49524     }
49525   }
49526   jresult = result;
49527   return jresult;
49528 }
49529
49530
49531 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49532   unsigned long jresult ;
49533   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49534   std::size_t result;
49535
49536   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49537   {
49538     try {
49539       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49540     } catch (std::out_of_range& e) {
49541       {
49542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49543       };
49544     } catch (std::exception& e) {
49545       {
49546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49547       };
49548     } catch (...) {
49549       {
49550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49551       };
49552     }
49553   }
49554   jresult = (unsigned long)result;
49555   return jresult;
49556 }
49557
49558
49559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49560   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49561   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49562
49563   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49564   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49565   {
49566     try {
49567       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49568     } catch (std::out_of_range& e) {
49569       {
49570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49571       };
49572     } catch (std::exception& e) {
49573       {
49574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49575       };
49576     } catch (...) {
49577       {
49578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49579       };
49580     }
49581   }
49582 }
49583
49584
49585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49586   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49587   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49588
49589   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49590   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49591   {
49592     try {
49593       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49594     } catch (std::out_of_range& e) {
49595       {
49596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49597       };
49598     } catch (std::exception& e) {
49599       {
49600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49601       };
49602     } catch (...) {
49603       {
49604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49605       };
49606     }
49607   }
49608 }
49609
49610
49611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49612   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49613   Dali::PropertyNotification *arg2 = 0 ;
49614
49615   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49616   arg2 = (Dali::PropertyNotification *)jarg2;
49617   if (!arg2) {
49618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49619     return ;
49620   }
49621   {
49622     try {
49623       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49624     } catch (std::out_of_range& e) {
49625       {
49626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49627       };
49628     } catch (std::exception& e) {
49629       {
49630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49631       };
49632     } catch (...) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49635       };
49636     }
49637   }
49638 }
49639
49640
49641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49642   void * jresult ;
49643   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49644
49645   {
49646     try {
49647       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49648     } catch (std::out_of_range& e) {
49649       {
49650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49651       };
49652     } catch (std::exception& e) {
49653       {
49654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49655       };
49656     } catch (...) {
49657       {
49658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49659       };
49660     }
49661   }
49662   jresult = (void *)result;
49663   return jresult;
49664 }
49665
49666
49667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49668   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49669
49670   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49671   {
49672     try {
49673       delete arg1;
49674     } catch (std::out_of_range& e) {
49675       {
49676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (std::exception& e) {
49679       {
49680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688 }
49689
49690
49691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49692   unsigned int jresult ;
49693   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49694   bool result;
49695
49696   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49697   {
49698     try {
49699       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49700     } catch (std::out_of_range& e) {
49701       {
49702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49703       };
49704     } catch (std::exception& e) {
49705       {
49706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49707       };
49708     } catch (...) {
49709       {
49710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49711       };
49712     }
49713   }
49714   jresult = result;
49715   return jresult;
49716 }
49717
49718
49719 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49720   unsigned long jresult ;
49721   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49722   std::size_t result;
49723
49724   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49725   {
49726     try {
49727       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49728     } catch (std::out_of_range& e) {
49729       {
49730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49731       };
49732     } catch (std::exception& e) {
49733       {
49734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49735       };
49736     } catch (...) {
49737       {
49738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49739       };
49740     }
49741   }
49742   jresult = (unsigned long)result;
49743   return jresult;
49744 }
49745
49746
49747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49748   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49749   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49750
49751   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49752   arg2 = (void (*)(Dali::Image))jarg2;
49753   {
49754     try {
49755       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49756     } catch (std::out_of_range& e) {
49757       {
49758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (std::exception& e) {
49761       {
49762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (...) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49767       };
49768     }
49769   }
49770 }
49771
49772
49773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49774   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49775   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49776
49777   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49778   arg2 = (void (*)(Dali::Image))jarg2;
49779   {
49780     try {
49781       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49782     } catch (std::out_of_range& e) {
49783       {
49784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49785       };
49786     } catch (std::exception& e) {
49787       {
49788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49789       };
49790     } catch (...) {
49791       {
49792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49793       };
49794     }
49795   }
49796 }
49797
49798
49799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49800   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49801   Dali::Image arg2 ;
49802   Dali::Image *argp2 ;
49803
49804   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49805   argp2 = (Dali::Image *)jarg2;
49806   if (!argp2) {
49807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49808     return ;
49809   }
49810   arg2 = *argp2;
49811   {
49812     try {
49813       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49814     } catch (std::out_of_range& e) {
49815       {
49816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49817       };
49818     } catch (std::exception& e) {
49819       {
49820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49821       };
49822     } catch (...) {
49823       {
49824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49825       };
49826     }
49827   }
49828 }
49829
49830
49831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49832   void * jresult ;
49833   Dali::Signal< void (Dali::Image) > *result = 0 ;
49834
49835   {
49836     try {
49837       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49838     } catch (std::out_of_range& e) {
49839       {
49840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49841       };
49842     } catch (std::exception& e) {
49843       {
49844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49845       };
49846     } catch (...) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49849       };
49850     }
49851   }
49852   jresult = (void *)result;
49853   return jresult;
49854 }
49855
49856
49857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49858   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49859
49860   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49861   {
49862     try {
49863       delete arg1;
49864     } catch (std::out_of_range& e) {
49865       {
49866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49867       };
49868     } catch (std::exception& e) {
49869       {
49870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49871       };
49872     } catch (...) {
49873       {
49874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49875       };
49876     }
49877   }
49878 }
49879
49880
49881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49882   void * jresult ;
49883   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49884
49885   {
49886     try {
49887       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49888     } catch (std::out_of_range& e) {
49889       {
49890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49891       };
49892     } catch (std::exception& e) {
49893       {
49894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49895       };
49896     } catch (...) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49899       };
49900     }
49901   }
49902   jresult = (void *)result;
49903   return jresult;
49904 }
49905
49906
49907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49908   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49909
49910   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49911   {
49912     try {
49913       delete arg1;
49914     } catch (std::out_of_range& e) {
49915       {
49916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49917       };
49918     } catch (std::exception& e) {
49919       {
49920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (...) {
49923       {
49924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49925       };
49926     }
49927   }
49928 }
49929
49930
49931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49932   unsigned int jresult ;
49933   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49934   bool result;
49935
49936   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49937   {
49938     try {
49939       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);
49940     } catch (std::out_of_range& e) {
49941       {
49942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49943       };
49944     } catch (std::exception& e) {
49945       {
49946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49947       };
49948     } catch (...) {
49949       {
49950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49951       };
49952     }
49953   }
49954   jresult = result;
49955   return jresult;
49956 }
49957
49958
49959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49960   unsigned long jresult ;
49961   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49962   std::size_t result;
49963
49964   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49965   {
49966     try {
49967       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);
49968     } catch (std::out_of_range& e) {
49969       {
49970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49971       };
49972     } catch (std::exception& e) {
49973       {
49974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49975       };
49976     } catch (...) {
49977       {
49978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49979       };
49980     }
49981   }
49982   jresult = (unsigned long)result;
49983   return jresult;
49984 }
49985
49986
49987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49988   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49989   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49990
49991   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49992   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49993   {
49994     try {
49995       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49996     } catch (std::out_of_range& e) {
49997       {
49998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49999       };
50000     } catch (std::exception& e) {
50001       {
50002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50003       };
50004     } catch (...) {
50005       {
50006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50007       };
50008     }
50009   }
50010 }
50011
50012
50013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50014   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50015   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50016
50017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50018   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50019   {
50020     try {
50021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50022     } catch (std::out_of_range& e) {
50023       {
50024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50025       };
50026     } catch (std::exception& e) {
50027       {
50028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50029       };
50030     } catch (...) {
50031       {
50032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50033       };
50034     }
50035   }
50036 }
50037
50038
50039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50040   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50041   Dali::Actor arg2 ;
50042   Dali::LongPressGesture *arg3 = 0 ;
50043   Dali::Actor *argp2 ;
50044
50045   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50046   argp2 = (Dali::Actor *)jarg2;
50047   if (!argp2) {
50048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50049     return ;
50050   }
50051   arg2 = *argp2;
50052   arg3 = (Dali::LongPressGesture *)jarg3;
50053   if (!arg3) {
50054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50055     return ;
50056   }
50057   {
50058     try {
50059       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50060     } catch (std::out_of_range& e) {
50061       {
50062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50063       };
50064     } catch (std::exception& e) {
50065       {
50066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50067       };
50068     } catch (...) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50071       };
50072     }
50073   }
50074 }
50075
50076
50077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50078   void * jresult ;
50079   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50080
50081   {
50082     try {
50083       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50084     } catch (std::out_of_range& e) {
50085       {
50086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50087       };
50088     } catch (std::exception& e) {
50089       {
50090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50091       };
50092     } catch (...) {
50093       {
50094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50095       };
50096     }
50097   }
50098   jresult = (void *)result;
50099   return jresult;
50100 }
50101
50102
50103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50104   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50105
50106   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50107   {
50108     try {
50109       delete arg1;
50110     } catch (std::out_of_range& e) {
50111       {
50112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50113       };
50114     } catch (std::exception& e) {
50115       {
50116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50117       };
50118     } catch (...) {
50119       {
50120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50121       };
50122     }
50123   }
50124 }
50125
50126
50127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50128   unsigned int jresult ;
50129   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50130   bool result;
50131
50132   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50133   {
50134     try {
50135       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);
50136     } catch (std::out_of_range& e) {
50137       {
50138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50139       };
50140     } catch (std::exception& e) {
50141       {
50142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50143       };
50144     } catch (...) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50147       };
50148     }
50149   }
50150   jresult = result;
50151   return jresult;
50152 }
50153
50154
50155 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50156   unsigned long jresult ;
50157   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50158   std::size_t result;
50159
50160   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50161   {
50162     try {
50163       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);
50164     } catch (std::out_of_range& e) {
50165       {
50166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50167       };
50168     } catch (std::exception& e) {
50169       {
50170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50171       };
50172     } catch (...) {
50173       {
50174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50175       };
50176     }
50177   }
50178   jresult = (unsigned long)result;
50179   return jresult;
50180 }
50181
50182
50183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50184   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50185   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50186
50187   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50188   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50189   {
50190     try {
50191       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50192     } catch (std::out_of_range& e) {
50193       {
50194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50195       };
50196     } catch (std::exception& e) {
50197       {
50198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50199       };
50200     } catch (...) {
50201       {
50202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50203       };
50204     }
50205   }
50206 }
50207
50208
50209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50210   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50211   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50212
50213   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50214   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50215   {
50216     try {
50217       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50218     } catch (std::out_of_range& e) {
50219       {
50220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50221       };
50222     } catch (std::exception& e) {
50223       {
50224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50225       };
50226     } catch (...) {
50227       {
50228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50229       };
50230     }
50231   }
50232 }
50233
50234
50235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50236   unsigned int jresult ;
50237   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50238   Dali::Actor arg2 ;
50239   Dali::TouchData *arg3 = 0 ;
50240   Dali::Actor *argp2 ;
50241   bool result;
50242
50243   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50244   argp2 = (Dali::Actor *)jarg2;
50245   if (!argp2) {
50246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50247     return 0;
50248   }
50249   arg2 = *argp2;
50250   arg3 = (Dali::TouchData *)jarg3;
50251   if (!arg3) {
50252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50253     return 0;
50254   }
50255   {
50256     try {
50257       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50258     } catch (std::out_of_range& e) {
50259       {
50260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50261       };
50262     } catch (std::exception& e) {
50263       {
50264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50265       };
50266     } catch (...) {
50267       {
50268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50269       };
50270     }
50271   }
50272   jresult = result;
50273   return jresult;
50274 }
50275
50276
50277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50278   void * jresult ;
50279   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50280
50281   {
50282     try {
50283       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50284     } catch (std::out_of_range& e) {
50285       {
50286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50287       };
50288     } catch (std::exception& e) {
50289       {
50290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50291       };
50292     } catch (...) {
50293       {
50294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50295       };
50296     }
50297   }
50298   jresult = (void *)result;
50299   return jresult;
50300 }
50301
50302
50303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50304   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50305
50306   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50307   {
50308     try {
50309       delete arg1;
50310     } catch (std::out_of_range& e) {
50311       {
50312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50313       };
50314     } catch (std::exception& e) {
50315       {
50316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50317       };
50318     } catch (...) {
50319       {
50320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50321       };
50322     }
50323   }
50324 }
50325
50326
50327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50328   unsigned int jresult ;
50329   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50330   bool result;
50331
50332   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50333   {
50334     try {
50335       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);
50336     } catch (std::out_of_range& e) {
50337       {
50338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50339       };
50340     } catch (std::exception& e) {
50341       {
50342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50343       };
50344     } catch (...) {
50345       {
50346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50347       };
50348     }
50349   }
50350   jresult = result;
50351   return jresult;
50352 }
50353
50354
50355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50356   unsigned long jresult ;
50357   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50358   std::size_t result;
50359
50360   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50361   {
50362     try {
50363       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);
50364     } catch (std::out_of_range& e) {
50365       {
50366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50367       };
50368     } catch (std::exception& e) {
50369       {
50370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50371       };
50372     } catch (...) {
50373       {
50374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50375       };
50376     }
50377   }
50378   jresult = (unsigned long)result;
50379   return jresult;
50380 }
50381
50382
50383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50384   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50385   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50386
50387   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50388   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50389   {
50390     try {
50391       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50392     } catch (std::out_of_range& e) {
50393       {
50394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50395       };
50396     } catch (std::exception& e) {
50397       {
50398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50399       };
50400     } catch (...) {
50401       {
50402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50403       };
50404     }
50405   }
50406 }
50407
50408
50409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50410   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50411   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50412
50413   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50414   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50415   {
50416     try {
50417       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50418     } catch (std::out_of_range& e) {
50419       {
50420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50421       };
50422     } catch (std::exception& e) {
50423       {
50424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50425       };
50426     } catch (...) {
50427       {
50428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50429       };
50430     }
50431   }
50432 }
50433
50434
50435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50436   unsigned int jresult ;
50437   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50438   Dali::Actor arg2 ;
50439   Dali::HoverEvent *arg3 = 0 ;
50440   Dali::Actor *argp2 ;
50441   bool result;
50442
50443   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50444   argp2 = (Dali::Actor *)jarg2;
50445   if (!argp2) {
50446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50447     return 0;
50448   }
50449   arg2 = *argp2;
50450   arg3 = (Dali::HoverEvent *)jarg3;
50451   if (!arg3) {
50452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50453     return 0;
50454   }
50455   {
50456     try {
50457       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50458     } catch (std::out_of_range& e) {
50459       {
50460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50461       };
50462     } catch (std::exception& e) {
50463       {
50464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50465       };
50466     } catch (...) {
50467       {
50468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50469       };
50470     }
50471   }
50472   jresult = result;
50473   return jresult;
50474 }
50475
50476
50477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50478   void * jresult ;
50479   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50480
50481   {
50482     try {
50483       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50484     } catch (std::out_of_range& e) {
50485       {
50486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50487       };
50488     } catch (std::exception& e) {
50489       {
50490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50491       };
50492     } catch (...) {
50493       {
50494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50495       };
50496     }
50497   }
50498   jresult = (void *)result;
50499   return jresult;
50500 }
50501
50502
50503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50504   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50505
50506   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50507   {
50508     try {
50509       delete arg1;
50510     } catch (std::out_of_range& e) {
50511       {
50512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50513       };
50514     } catch (std::exception& e) {
50515       {
50516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50517       };
50518     } catch (...) {
50519       {
50520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50521       };
50522     }
50523   }
50524 }
50525
50526
50527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50528   unsigned int jresult ;
50529   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50530   bool result;
50531
50532   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50533   {
50534     try {
50535       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);
50536     } catch (std::out_of_range& e) {
50537       {
50538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50539       };
50540     } catch (std::exception& e) {
50541       {
50542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50543       };
50544     } catch (...) {
50545       {
50546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50547       };
50548     }
50549   }
50550   jresult = result;
50551   return jresult;
50552 }
50553
50554
50555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50556   unsigned long jresult ;
50557   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50558   std::size_t result;
50559
50560   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50561   {
50562     try {
50563       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);
50564     } catch (std::out_of_range& e) {
50565       {
50566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50567       };
50568     } catch (std::exception& e) {
50569       {
50570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50571       };
50572     } catch (...) {
50573       {
50574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50575       };
50576     }
50577   }
50578   jresult = (unsigned long)result;
50579   return jresult;
50580 }
50581
50582
50583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50584   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50585   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50586
50587   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50588   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50589   {
50590     try {
50591       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50592     } catch (std::out_of_range& e) {
50593       {
50594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50595       };
50596     } catch (std::exception& e) {
50597       {
50598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50599       };
50600     } catch (...) {
50601       {
50602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50603       };
50604     }
50605   }
50606 }
50607
50608
50609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50610   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50611   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50612
50613   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50614   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50615   {
50616     try {
50617       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50618     } catch (std::out_of_range& e) {
50619       {
50620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50621       };
50622     } catch (std::exception& e) {
50623       {
50624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50625       };
50626     } catch (...) {
50627       {
50628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50629       };
50630     }
50631   }
50632 }
50633
50634
50635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50636   unsigned int jresult ;
50637   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50638   Dali::Actor arg2 ;
50639   Dali::WheelEvent *arg3 = 0 ;
50640   Dali::Actor *argp2 ;
50641   bool result;
50642
50643   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50644   argp2 = (Dali::Actor *)jarg2;
50645   if (!argp2) {
50646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50647     return 0;
50648   }
50649   arg2 = *argp2;
50650   arg3 = (Dali::WheelEvent *)jarg3;
50651   if (!arg3) {
50652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50653     return 0;
50654   }
50655   {
50656     try {
50657       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50658     } catch (std::out_of_range& e) {
50659       {
50660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50661       };
50662     } catch (std::exception& e) {
50663       {
50664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50665       };
50666     } catch (...) {
50667       {
50668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50669       };
50670     }
50671   }
50672   jresult = result;
50673   return jresult;
50674 }
50675
50676
50677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50678   void * jresult ;
50679   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50680
50681   {
50682     try {
50683       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50684     } catch (std::out_of_range& e) {
50685       {
50686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50687       };
50688     } catch (std::exception& e) {
50689       {
50690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50691       };
50692     } catch (...) {
50693       {
50694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50695       };
50696     }
50697   }
50698   jresult = (void *)result;
50699   return jresult;
50700 }
50701
50702
50703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50704   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50705
50706   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50707   {
50708     try {
50709       delete arg1;
50710     } catch (std::out_of_range& e) {
50711       {
50712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50713       };
50714     } catch (std::exception& e) {
50715       {
50716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50717       };
50718     } catch (...) {
50719       {
50720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50721       };
50722     }
50723   }
50724 }
50725
50726
50727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50728   unsigned int jresult ;
50729   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50730   bool result;
50731
50732   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50733   {
50734     try {
50735       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50736     } catch (std::out_of_range& e) {
50737       {
50738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50739       };
50740     } catch (std::exception& e) {
50741       {
50742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50743       };
50744     } catch (...) {
50745       {
50746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50747       };
50748     }
50749   }
50750   jresult = result;
50751   return jresult;
50752 }
50753
50754
50755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50756   unsigned long jresult ;
50757   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50758   std::size_t result;
50759
50760   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50761   {
50762     try {
50763       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50764     } catch (std::out_of_range& e) {
50765       {
50766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50767       };
50768     } catch (std::exception& e) {
50769       {
50770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50771       };
50772     } catch (...) {
50773       {
50774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50775       };
50776     }
50777   }
50778   jresult = (unsigned long)result;
50779   return jresult;
50780 }
50781
50782
50783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50784   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50785   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50786
50787   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50788   arg2 = (void (*)(Dali::Actor))jarg2;
50789   {
50790     try {
50791       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50792     } catch (std::out_of_range& e) {
50793       {
50794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50795       };
50796     } catch (std::exception& e) {
50797       {
50798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50799       };
50800     } catch (...) {
50801       {
50802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50803       };
50804     }
50805   }
50806 }
50807
50808
50809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50810   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50811   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50812
50813   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50814   arg2 = (void (*)(Dali::Actor))jarg2;
50815   {
50816     try {
50817       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50818     } catch (std::out_of_range& e) {
50819       {
50820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50821       };
50822     } catch (std::exception& e) {
50823       {
50824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50825       };
50826     } catch (...) {
50827       {
50828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50829       };
50830     }
50831   }
50832 }
50833
50834
50835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50836   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50837   Dali::Actor arg2 ;
50838   Dali::Actor *argp2 ;
50839
50840   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50841   argp2 = (Dali::Actor *)jarg2;
50842   if (!argp2) {
50843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50844     return ;
50845   }
50846   arg2 = *argp2;
50847   {
50848     try {
50849       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50850     } catch (std::out_of_range& e) {
50851       {
50852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50853       };
50854     } catch (std::exception& e) {
50855       {
50856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50857       };
50858     } catch (...) {
50859       {
50860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50861       };
50862     }
50863   }
50864 }
50865
50866
50867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50868   void * jresult ;
50869   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50870
50871   {
50872     try {
50873       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50874     } catch (std::out_of_range& e) {
50875       {
50876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50877       };
50878     } catch (std::exception& e) {
50879       {
50880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50881       };
50882     } catch (...) {
50883       {
50884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50885       };
50886     }
50887   }
50888   jresult = (void *)result;
50889   return jresult;
50890 }
50891
50892
50893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50894   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50895
50896   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50897   {
50898     try {
50899       delete arg1;
50900     } catch (std::out_of_range& e) {
50901       {
50902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50903       };
50904     } catch (std::exception& e) {
50905       {
50906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50907       };
50908     } catch (...) {
50909       {
50910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50911       };
50912     }
50913   }
50914 }
50915
50916
50917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50918   unsigned int jresult ;
50919   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50920   bool result;
50921
50922   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50923   {
50924     try {
50925       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50926     } catch (std::out_of_range& e) {
50927       {
50928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50929       };
50930     } catch (std::exception& e) {
50931       {
50932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50933       };
50934     } catch (...) {
50935       {
50936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50937       };
50938     }
50939   }
50940   jresult = result;
50941   return jresult;
50942 }
50943
50944
50945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50946   unsigned long jresult ;
50947   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50948   std::size_t result;
50949
50950   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50951   {
50952     try {
50953       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50954     } catch (std::out_of_range& e) {
50955       {
50956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50957       };
50958     } catch (std::exception& e) {
50959       {
50960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50961       };
50962     } catch (...) {
50963       {
50964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50965       };
50966     }
50967   }
50968   jresult = (unsigned long)result;
50969   return jresult;
50970 }
50971
50972
50973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50974   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50975   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50976
50977   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50978   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50979   {
50980     try {
50981       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50982     } catch (std::out_of_range& e) {
50983       {
50984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50985       };
50986     } catch (std::exception& e) {
50987       {
50988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50989       };
50990     } catch (...) {
50991       {
50992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50993       };
50994     }
50995   }
50996 }
50997
50998
50999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51000   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51001   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51002
51003   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51004   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51005   {
51006     try {
51007       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51008     } catch (std::out_of_range& e) {
51009       {
51010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51011       };
51012     } catch (std::exception& e) {
51013       {
51014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51015       };
51016     } catch (...) {
51017       {
51018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51019       };
51020     }
51021   }
51022 }
51023
51024
51025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51026   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51027   Dali::KeyEvent *arg2 = 0 ;
51028
51029   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51030   arg2 = (Dali::KeyEvent *)jarg2;
51031   if (!arg2) {
51032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51033     return ;
51034   }
51035   {
51036     try {
51037       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51038     } catch (std::out_of_range& e) {
51039       {
51040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51041       };
51042     } catch (std::exception& e) {
51043       {
51044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51045       };
51046     } catch (...) {
51047       {
51048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51049       };
51050     }
51051   }
51052 }
51053
51054
51055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51056   void * jresult ;
51057   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51058
51059   {
51060     try {
51061       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51062     } catch (std::out_of_range& e) {
51063       {
51064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51065       };
51066     } catch (std::exception& e) {
51067       {
51068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51069       };
51070     } catch (...) {
51071       {
51072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51073       };
51074     }
51075   }
51076   jresult = (void *)result;
51077   return jresult;
51078 }
51079
51080
51081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51082   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51083
51084   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51085   {
51086     try {
51087       delete arg1;
51088     } catch (std::out_of_range& e) {
51089       {
51090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51091       };
51092     } catch (std::exception& e) {
51093       {
51094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51095       };
51096     } catch (...) {
51097       {
51098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51099       };
51100     }
51101   }
51102 }
51103
51104
51105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51106   unsigned int jresult ;
51107   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51108   bool result;
51109
51110   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51111   {
51112     try {
51113       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51114     } catch (std::out_of_range& e) {
51115       {
51116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51117       };
51118     } catch (std::exception& e) {
51119       {
51120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51121       };
51122     } catch (...) {
51123       {
51124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51125       };
51126     }
51127   }
51128   jresult = result;
51129   return jresult;
51130 }
51131
51132
51133 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51134   unsigned long jresult ;
51135   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51136   std::size_t result;
51137
51138   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51139   {
51140     try {
51141       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51142     } catch (std::out_of_range& e) {
51143       {
51144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51145       };
51146     } catch (std::exception& e) {
51147       {
51148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51149       };
51150     } catch (...) {
51151       {
51152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51153       };
51154     }
51155   }
51156   jresult = (unsigned long)result;
51157   return jresult;
51158 }
51159
51160
51161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51162   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51163   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51164
51165   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51166   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51167   {
51168     try {
51169       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51170     } catch (std::out_of_range& e) {
51171       {
51172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51173       };
51174     } catch (std::exception& e) {
51175       {
51176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51177       };
51178     } catch (...) {
51179       {
51180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51181       };
51182     }
51183   }
51184 }
51185
51186
51187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51188   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51189   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51190
51191   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51192   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51193   {
51194     try {
51195       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51196     } catch (std::out_of_range& e) {
51197       {
51198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51199       };
51200     } catch (std::exception& e) {
51201       {
51202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51203       };
51204     } catch (...) {
51205       {
51206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51207       };
51208     }
51209   }
51210 }
51211
51212
51213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51214   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51215   Dali::TouchData *arg2 = 0 ;
51216
51217   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51218   arg2 = (Dali::TouchData *)jarg2;
51219   if (!arg2) {
51220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51221     return ;
51222   }
51223   {
51224     try {
51225       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51226     } catch (std::out_of_range& e) {
51227       {
51228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51229       };
51230     } catch (std::exception& e) {
51231       {
51232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51233       };
51234     } catch (...) {
51235       {
51236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51237       };
51238     }
51239   }
51240 }
51241
51242
51243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51244   void * jresult ;
51245   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51246
51247   {
51248     try {
51249       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51250     } catch (std::out_of_range& e) {
51251       {
51252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51253       };
51254     } catch (std::exception& e) {
51255       {
51256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51257       };
51258     } catch (...) {
51259       {
51260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51261       };
51262     }
51263   }
51264   jresult = (void *)result;
51265   return jresult;
51266 }
51267
51268
51269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51270   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51271
51272   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51273   {
51274     try {
51275       delete arg1;
51276     } catch (std::out_of_range& e) {
51277       {
51278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51279       };
51280     } catch (std::exception& e) {
51281       {
51282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (...) {
51285       {
51286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51287       };
51288     }
51289   }
51290 }
51291
51292
51293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51294   unsigned int jresult ;
51295   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51296   bool result;
51297
51298   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51299   {
51300     try {
51301       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51302     } catch (std::out_of_range& e) {
51303       {
51304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51305       };
51306     } catch (std::exception& e) {
51307       {
51308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51309       };
51310     } catch (...) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51313       };
51314     }
51315   }
51316   jresult = result;
51317   return jresult;
51318 }
51319
51320
51321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51322   unsigned long jresult ;
51323   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51324   std::size_t result;
51325
51326   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51327   {
51328     try {
51329       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51330     } catch (std::out_of_range& e) {
51331       {
51332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51333       };
51334     } catch (std::exception& e) {
51335       {
51336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51337       };
51338     } catch (...) {
51339       {
51340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51341       };
51342     }
51343   }
51344   jresult = (unsigned long)result;
51345   return jresult;
51346 }
51347
51348
51349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51350   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51351   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51352
51353   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51354   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51355   {
51356     try {
51357       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51358     } catch (std::out_of_range& e) {
51359       {
51360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51361       };
51362     } catch (std::exception& e) {
51363       {
51364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51365       };
51366     } catch (...) {
51367       {
51368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51369       };
51370     }
51371   }
51372 }
51373
51374
51375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51376   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51377   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51378
51379   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51380   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51381   {
51382     try {
51383       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51384     } catch (std::out_of_range& e) {
51385       {
51386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51387       };
51388     } catch (std::exception& e) {
51389       {
51390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51391       };
51392     } catch (...) {
51393       {
51394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51395       };
51396     }
51397   }
51398 }
51399
51400
51401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51402   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51403   Dali::WheelEvent *arg2 = 0 ;
51404
51405   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51406   arg2 = (Dali::WheelEvent *)jarg2;
51407   if (!arg2) {
51408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51409     return ;
51410   }
51411   {
51412     try {
51413       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51414     } catch (std::out_of_range& e) {
51415       {
51416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51417       };
51418     } catch (std::exception& e) {
51419       {
51420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51421       };
51422     } catch (...) {
51423       {
51424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51425       };
51426     }
51427   }
51428 }
51429
51430
51431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51432   void * jresult ;
51433   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51434
51435   {
51436     try {
51437       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51438     } catch (std::out_of_range& e) {
51439       {
51440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51441       };
51442     } catch (std::exception& e) {
51443       {
51444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51445       };
51446     } catch (...) {
51447       {
51448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51449       };
51450     }
51451   }
51452   jresult = (void *)result;
51453   return jresult;
51454 }
51455
51456
51457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51458   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51459
51460   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51461   {
51462     try {
51463       delete arg1;
51464     } catch (std::out_of_range& e) {
51465       {
51466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51467       };
51468     } catch (std::exception& e) {
51469       {
51470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51471       };
51472     } catch (...) {
51473       {
51474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51475       };
51476     }
51477   }
51478 }
51479
51480
51481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51482   void * jresult ;
51483   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51484
51485   {
51486     try {
51487       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51488     } catch (std::out_of_range& e) {
51489       {
51490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51491       };
51492     } catch (std::exception& e) {
51493       {
51494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51495       };
51496     } catch (...) {
51497       {
51498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51499       };
51500     }
51501   }
51502   jresult = (void *)result;
51503   return jresult;
51504 }
51505
51506
51507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51508   void * jresult ;
51509   Dali::Radian arg1 ;
51510   Dali::Radian arg2 ;
51511   Dali::Radian *argp1 ;
51512   Dali::Radian *argp2 ;
51513   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51514
51515   argp1 = (Dali::Radian *)jarg1;
51516   if (!argp1) {
51517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51518     return 0;
51519   }
51520   arg1 = *argp1;
51521   argp2 = (Dali::Radian *)jarg2;
51522   if (!argp2) {
51523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51524     return 0;
51525   }
51526   arg2 = *argp2;
51527   {
51528     try {
51529       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51530     } catch (std::out_of_range& e) {
51531       {
51532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51533       };
51534     } catch (std::exception& e) {
51535       {
51536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51537       };
51538     } catch (...) {
51539       {
51540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51541       };
51542     }
51543   }
51544   jresult = (void *)result;
51545   return jresult;
51546 }
51547
51548
51549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51550   void * jresult ;
51551   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51552   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51553
51554   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51555   if (!arg1) {
51556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51557     return 0;
51558   }
51559   {
51560     try {
51561       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51562     } catch (std::out_of_range& e) {
51563       {
51564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51565       };
51566     } catch (std::exception& e) {
51567       {
51568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51569       };
51570     } catch (...) {
51571       {
51572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51573       };
51574     }
51575   }
51576   jresult = (void *)result;
51577   return jresult;
51578 }
51579
51580
51581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51582   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51583   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51584
51585   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51586   arg2 = (Dali::Radian *)jarg2;
51587   if (arg1) (arg1)->first = *arg2;
51588 }
51589
51590
51591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51592   void * jresult ;
51593   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51594   Dali::Radian *result = 0 ;
51595
51596   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51597   result = (Dali::Radian *)& ((arg1)->first);
51598   jresult = (void *)result;
51599   return jresult;
51600 }
51601
51602
51603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51604   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51605   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51606
51607   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51608   arg2 = (Dali::Radian *)jarg2;
51609   if (arg1) (arg1)->second = *arg2;
51610 }
51611
51612
51613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51614   void * jresult ;
51615   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51616   Dali::Radian *result = 0 ;
51617
51618   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51619   result = (Dali::Radian *)& ((arg1)->second);
51620   jresult = (void *)result;
51621   return jresult;
51622 }
51623
51624
51625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51626   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51627
51628   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51629   {
51630     try {
51631       delete arg1;
51632     } catch (std::out_of_range& e) {
51633       {
51634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51635       };
51636     } catch (std::exception& e) {
51637       {
51638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51639       };
51640     } catch (...) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51643       };
51644     }
51645   }
51646 }
51647
51648
51649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51650   unsigned int jresult ;
51651   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51652   bool result;
51653
51654   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51655   {
51656     try {
51657       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);
51658     } catch (std::out_of_range& e) {
51659       {
51660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51661       };
51662     } catch (std::exception& e) {
51663       {
51664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51665       };
51666     } catch (...) {
51667       {
51668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51669       };
51670     }
51671   }
51672   jresult = result;
51673   return jresult;
51674 }
51675
51676
51677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51678   unsigned long jresult ;
51679   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51680   std::size_t result;
51681
51682   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51683   {
51684     try {
51685       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);
51686     } catch (std::out_of_range& e) {
51687       {
51688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51689       };
51690     } catch (std::exception& e) {
51691       {
51692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51693       };
51694     } catch (...) {
51695       {
51696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51697       };
51698     }
51699   }
51700   jresult = (unsigned long)result;
51701   return jresult;
51702 }
51703
51704
51705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51706   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51707   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51708
51709   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51710   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51711   {
51712     try {
51713       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51714     } catch (std::out_of_range& e) {
51715       {
51716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51717       };
51718     } catch (std::exception& e) {
51719       {
51720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51721       };
51722     } catch (...) {
51723       {
51724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51725       };
51726     }
51727   }
51728 }
51729
51730
51731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51732   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51733   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51734
51735   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51736   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51737   {
51738     try {
51739       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51740     } catch (std::out_of_range& e) {
51741       {
51742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51743       };
51744     } catch (std::exception& e) {
51745       {
51746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51747       };
51748     } catch (...) {
51749       {
51750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51751       };
51752     }
51753   }
51754 }
51755
51756
51757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51758   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51759   Dali::Actor arg2 ;
51760   Dali::PanGesture *arg3 = 0 ;
51761   Dali::Actor *argp2 ;
51762
51763   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51764   argp2 = (Dali::Actor *)jarg2;
51765   if (!argp2) {
51766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51767     return ;
51768   }
51769   arg2 = *argp2;
51770   arg3 = (Dali::PanGesture *)jarg3;
51771   if (!arg3) {
51772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51773     return ;
51774   }
51775   {
51776     try {
51777       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51778     } catch (std::out_of_range& e) {
51779       {
51780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51781       };
51782     } catch (std::exception& e) {
51783       {
51784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51785       };
51786     } catch (...) {
51787       {
51788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51789       };
51790     }
51791   }
51792 }
51793
51794
51795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51796   void * jresult ;
51797   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51798
51799   {
51800     try {
51801       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51802     } catch (std::out_of_range& e) {
51803       {
51804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51805       };
51806     } catch (std::exception& e) {
51807       {
51808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51809       };
51810     } catch (...) {
51811       {
51812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51813       };
51814     }
51815   }
51816   jresult = (void *)result;
51817   return jresult;
51818 }
51819
51820
51821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51822   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51823
51824   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51825   {
51826     try {
51827       delete arg1;
51828     } catch (std::out_of_range& e) {
51829       {
51830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51831       };
51832     } catch (std::exception& e) {
51833       {
51834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51835       };
51836     } catch (...) {
51837       {
51838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51839       };
51840     }
51841   }
51842 }
51843
51844
51845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51846   unsigned int jresult ;
51847   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51848   bool result;
51849
51850   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51851   {
51852     try {
51853       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);
51854     } catch (std::out_of_range& e) {
51855       {
51856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51857       };
51858     } catch (std::exception& e) {
51859       {
51860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51861       };
51862     } catch (...) {
51863       {
51864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51865       };
51866     }
51867   }
51868   jresult = result;
51869   return jresult;
51870 }
51871
51872
51873 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51874   unsigned long jresult ;
51875   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51876   std::size_t result;
51877
51878   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51879   {
51880     try {
51881       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);
51882     } catch (std::out_of_range& e) {
51883       {
51884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51885       };
51886     } catch (std::exception& e) {
51887       {
51888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (...) {
51891       {
51892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51893       };
51894     }
51895   }
51896   jresult = (unsigned long)result;
51897   return jresult;
51898 }
51899
51900
51901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51902   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51903   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51904
51905   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51906   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51907   {
51908     try {
51909       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51910     } catch (std::out_of_range& e) {
51911       {
51912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51913       };
51914     } catch (std::exception& e) {
51915       {
51916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51917       };
51918     } catch (...) {
51919       {
51920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51921       };
51922     }
51923   }
51924 }
51925
51926
51927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51928   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51929   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51930
51931   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51932   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51933   {
51934     try {
51935       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51936     } catch (std::out_of_range& e) {
51937       {
51938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51939       };
51940     } catch (std::exception& e) {
51941       {
51942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51943       };
51944     } catch (...) {
51945       {
51946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51947       };
51948     }
51949   }
51950 }
51951
51952
51953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51954   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51955   Dali::Actor arg2 ;
51956   Dali::PinchGesture *arg3 = 0 ;
51957   Dali::Actor *argp2 ;
51958
51959   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51960   argp2 = (Dali::Actor *)jarg2;
51961   if (!argp2) {
51962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51963     return ;
51964   }
51965   arg2 = *argp2;
51966   arg3 = (Dali::PinchGesture *)jarg3;
51967   if (!arg3) {
51968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51969     return ;
51970   }
51971   {
51972     try {
51973       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51974     } catch (std::out_of_range& e) {
51975       {
51976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51977       };
51978     } catch (std::exception& e) {
51979       {
51980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51981       };
51982     } catch (...) {
51983       {
51984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51985       };
51986     }
51987   }
51988 }
51989
51990
51991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51992   void * jresult ;
51993   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51994
51995   {
51996     try {
51997       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51998     } catch (std::out_of_range& e) {
51999       {
52000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52001       };
52002     } catch (std::exception& e) {
52003       {
52004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52005       };
52006     } catch (...) {
52007       {
52008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52009       };
52010     }
52011   }
52012   jresult = (void *)result;
52013   return jresult;
52014 }
52015
52016
52017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52018   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52019
52020   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52021   {
52022     try {
52023       delete arg1;
52024     } catch (std::out_of_range& e) {
52025       {
52026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52027       };
52028     } catch (std::exception& e) {
52029       {
52030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52031       };
52032     } catch (...) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52035       };
52036     }
52037   }
52038 }
52039
52040
52041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52042   unsigned int jresult ;
52043   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52044   bool result;
52045
52046   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52047   {
52048     try {
52049       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);
52050     } catch (std::out_of_range& e) {
52051       {
52052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52053       };
52054     } catch (std::exception& e) {
52055       {
52056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52057       };
52058     } catch (...) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52061       };
52062     }
52063   }
52064   jresult = result;
52065   return jresult;
52066 }
52067
52068
52069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52070   unsigned long jresult ;
52071   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52072   std::size_t result;
52073
52074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52075   {
52076     try {
52077       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);
52078     } catch (std::out_of_range& e) {
52079       {
52080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52081       };
52082     } catch (std::exception& e) {
52083       {
52084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52085       };
52086     } catch (...) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52089       };
52090     }
52091   }
52092   jresult = (unsigned long)result;
52093   return jresult;
52094 }
52095
52096
52097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52098   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52099   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52100
52101   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52102   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52103   {
52104     try {
52105       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52106     } catch (std::out_of_range& e) {
52107       {
52108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52109       };
52110     } catch (std::exception& e) {
52111       {
52112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52113       };
52114     } catch (...) {
52115       {
52116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52117       };
52118     }
52119   }
52120 }
52121
52122
52123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52124   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52125   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52126
52127   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52128   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52129   {
52130     try {
52131       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52132     } catch (std::out_of_range& e) {
52133       {
52134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52135       };
52136     } catch (std::exception& e) {
52137       {
52138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52139       };
52140     } catch (...) {
52141       {
52142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52143       };
52144     }
52145   }
52146 }
52147
52148
52149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52150   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52151   Dali::Actor arg2 ;
52152   Dali::TapGesture *arg3 = 0 ;
52153   Dali::Actor *argp2 ;
52154
52155   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52156   argp2 = (Dali::Actor *)jarg2;
52157   if (!argp2) {
52158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52159     return ;
52160   }
52161   arg2 = *argp2;
52162   arg3 = (Dali::TapGesture *)jarg3;
52163   if (!arg3) {
52164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52165     return ;
52166   }
52167   {
52168     try {
52169       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52170     } catch (std::out_of_range& e) {
52171       {
52172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52173       };
52174     } catch (std::exception& e) {
52175       {
52176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52177       };
52178     } catch (...) {
52179       {
52180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52181       };
52182     }
52183   }
52184 }
52185
52186
52187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52188   void * jresult ;
52189   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52190
52191   {
52192     try {
52193       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52194     } catch (std::out_of_range& e) {
52195       {
52196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52197       };
52198     } catch (std::exception& e) {
52199       {
52200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52201       };
52202     } catch (...) {
52203       {
52204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52205       };
52206     }
52207   }
52208   jresult = (void *)result;
52209   return jresult;
52210 }
52211
52212
52213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52214   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52215
52216   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52217   {
52218     try {
52219       delete arg1;
52220     } catch (std::out_of_range& e) {
52221       {
52222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52223       };
52224     } catch (std::exception& e) {
52225       {
52226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52227       };
52228     } catch (...) {
52229       {
52230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52231       };
52232     }
52233   }
52234 }
52235
52236
52237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52238   unsigned int jresult ;
52239   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52240   bool result;
52241
52242   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52243   {
52244     try {
52245       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52246     } catch (std::out_of_range& e) {
52247       {
52248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52249       };
52250     } catch (std::exception& e) {
52251       {
52252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52253       };
52254     } catch (...) {
52255       {
52256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52257       };
52258     }
52259   }
52260   jresult = result;
52261   return jresult;
52262 }
52263
52264
52265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52266   unsigned long jresult ;
52267   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52268   std::size_t result;
52269
52270   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52271   {
52272     try {
52273       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52274     } catch (std::out_of_range& e) {
52275       {
52276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52277       };
52278     } catch (std::exception& e) {
52279       {
52280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52281       };
52282     } catch (...) {
52283       {
52284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52285       };
52286     }
52287   }
52288   jresult = (unsigned long)result;
52289   return jresult;
52290 }
52291
52292
52293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52294   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52295   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52296
52297   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52298   arg2 = (void (*)(Dali::Animation &))jarg2;
52299   {
52300     try {
52301       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52302     } catch (std::out_of_range& e) {
52303       {
52304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52305       };
52306     } catch (std::exception& e) {
52307       {
52308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52309       };
52310     } catch (...) {
52311       {
52312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52313       };
52314     }
52315   }
52316 }
52317
52318
52319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52320   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52321   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52322
52323   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52324   arg2 = (void (*)(Dali::Animation &))jarg2;
52325   {
52326     try {
52327       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52328     } catch (std::out_of_range& e) {
52329       {
52330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52331       };
52332     } catch (std::exception& e) {
52333       {
52334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52335       };
52336     } catch (...) {
52337       {
52338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52339       };
52340     }
52341   }
52342 }
52343
52344
52345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52346   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52347   Dali::Animation *arg2 = 0 ;
52348
52349   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52350   arg2 = (Dali::Animation *)jarg2;
52351   if (!arg2) {
52352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52353     return ;
52354   }
52355   {
52356     try {
52357       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52358     } catch (std::out_of_range& e) {
52359       {
52360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52361       };
52362     } catch (std::exception& e) {
52363       {
52364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52365       };
52366     } catch (...) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52369       };
52370     }
52371   }
52372 }
52373
52374
52375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52376   void * jresult ;
52377   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52378
52379   {
52380     try {
52381       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52382     } catch (std::out_of_range& e) {
52383       {
52384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52385       };
52386     } catch (std::exception& e) {
52387       {
52388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52389       };
52390     } catch (...) {
52391       {
52392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52393       };
52394     }
52395   }
52396   jresult = (void *)result;
52397   return jresult;
52398 }
52399
52400
52401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52402   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52403
52404   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52405   {
52406     try {
52407       delete arg1;
52408     } catch (std::out_of_range& e) {
52409       {
52410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52411       };
52412     } catch (std::exception& e) {
52413       {
52414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52415       };
52416     } catch (...) {
52417       {
52418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52419       };
52420     }
52421   }
52422 }
52423
52424
52425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52426   unsigned int jresult ;
52427   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52428   bool result;
52429
52430   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52431   {
52432     try {
52433       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52434     } catch (std::out_of_range& e) {
52435       {
52436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52437       };
52438     } catch (std::exception& e) {
52439       {
52440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (...) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52445       };
52446     }
52447   }
52448   jresult = result;
52449   return jresult;
52450 }
52451
52452
52453 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52454   unsigned long jresult ;
52455   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52456   std::size_t result;
52457
52458   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52459   {
52460     try {
52461       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52462     } catch (std::out_of_range& e) {
52463       {
52464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52465       };
52466     } catch (std::exception& e) {
52467       {
52468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52469       };
52470     } catch (...) {
52471       {
52472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52473       };
52474     }
52475   }
52476   jresult = (unsigned long)result;
52477   return jresult;
52478 }
52479
52480
52481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52482   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52483   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52484
52485   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52486   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52487   {
52488     try {
52489       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52490     } catch (std::out_of_range& e) {
52491       {
52492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52493       };
52494     } catch (std::exception& e) {
52495       {
52496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52497       };
52498     } catch (...) {
52499       {
52500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52501       };
52502     }
52503   }
52504 }
52505
52506
52507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52508   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52509   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52510
52511   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52512   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52513   {
52514     try {
52515       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52516     } catch (std::out_of_range& e) {
52517       {
52518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52519       };
52520     } catch (std::exception& e) {
52521       {
52522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52523       };
52524     } catch (...) {
52525       {
52526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52527       };
52528     }
52529   }
52530 }
52531
52532
52533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52534   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52535   Dali::ResourceImage arg2 ;
52536   Dali::ResourceImage *argp2 ;
52537
52538   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52539   argp2 = (Dali::ResourceImage *)jarg2;
52540   if (!argp2) {
52541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52542     return ;
52543   }
52544   arg2 = *argp2;
52545   {
52546     try {
52547       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52548     } catch (std::out_of_range& e) {
52549       {
52550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52551       };
52552     } catch (std::exception& e) {
52553       {
52554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52555       };
52556     } catch (...) {
52557       {
52558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52559       };
52560     }
52561   }
52562 }
52563
52564
52565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52566   void * jresult ;
52567   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52568
52569   {
52570     try {
52571       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52572     } catch (std::out_of_range& e) {
52573       {
52574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52575       };
52576     } catch (std::exception& e) {
52577       {
52578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52579       };
52580     } catch (...) {
52581       {
52582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52583       };
52584     }
52585   }
52586   jresult = (void *)result;
52587   return jresult;
52588 }
52589
52590
52591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52592   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52593
52594   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52595   {
52596     try {
52597       delete arg1;
52598     } catch (std::out_of_range& e) {
52599       {
52600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52601       };
52602     } catch (std::exception& e) {
52603       {
52604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52605       };
52606     } catch (...) {
52607       {
52608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52609       };
52610     }
52611   }
52612 }
52613
52614
52615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52616   unsigned int jresult ;
52617   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52618   bool result;
52619
52620   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52621   {
52622     try {
52623       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);
52624     } catch (std::out_of_range& e) {
52625       {
52626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52627       };
52628     } catch (std::exception& e) {
52629       {
52630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52631       };
52632     } catch (...) {
52633       {
52634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52635       };
52636     }
52637   }
52638   jresult = result;
52639   return jresult;
52640 }
52641
52642
52643 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52644   unsigned long jresult ;
52645   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52646   std::size_t result;
52647
52648   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52649   {
52650     try {
52651       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);
52652     } catch (std::out_of_range& e) {
52653       {
52654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52655       };
52656     } catch (std::exception& e) {
52657       {
52658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52659       };
52660     } catch (...) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52663       };
52664     }
52665   }
52666   jresult = (unsigned long)result;
52667   return jresult;
52668 }
52669
52670
52671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52672   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52673   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52674
52675   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52676   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52677   {
52678     try {
52679       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52680     } catch (std::out_of_range& e) {
52681       {
52682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52683       };
52684     } catch (std::exception& e) {
52685       {
52686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52687       };
52688     } catch (...) {
52689       {
52690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52691       };
52692     }
52693   }
52694 }
52695
52696
52697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52698   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52699   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52700
52701   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52702   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52703   {
52704     try {
52705       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52706     } catch (std::out_of_range& e) {
52707       {
52708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52709       };
52710     } catch (std::exception& e) {
52711       {
52712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52713       };
52714     } catch (...) {
52715       {
52716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52717       };
52718     }
52719   }
52720 }
52721
52722
52723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52724   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52725   Dali::Actor arg2 ;
52726   bool arg3 ;
52727   Dali::DevelActor::VisibilityChange::Type arg4 ;
52728   Dali::Actor *argp2 ;
52729
52730   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52731   argp2 = (Dali::Actor *)jarg2;
52732   if (!argp2) {
52733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52734     return ;
52735   }
52736   arg2 = *argp2;
52737   arg3 = jarg3 ? true : false;
52738   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52739   {
52740     try {
52741       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52742     } catch (std::out_of_range& e) {
52743       {
52744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52745       };
52746     } catch (std::exception& e) {
52747       {
52748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52749       };
52750     } catch (...) {
52751       {
52752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52753       };
52754     }
52755   }
52756 }
52757
52758
52759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52760   void * jresult ;
52761   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52762
52763   {
52764     try {
52765       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52766     } catch (std::out_of_range& e) {
52767       {
52768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52769       };
52770     } catch (std::exception& e) {
52771       {
52772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (...) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52777       };
52778     }
52779   }
52780   jresult = (void *)result;
52781   return jresult;
52782 }
52783
52784
52785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52786   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52787
52788   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52789   {
52790     try {
52791       delete arg1;
52792     } catch (std::out_of_range& e) {
52793       {
52794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52795       };
52796     } catch (std::exception& e) {
52797       {
52798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52799       };
52800     } catch (...) {
52801       {
52802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52803       };
52804     }
52805   }
52806 }
52807
52808
52809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52810   void * jresult ;
52811   Dali::Timer *result = 0 ;
52812
52813   {
52814     try {
52815       result = (Dali::Timer *)new Dali::Timer();
52816     } catch (std::out_of_range& e) {
52817       {
52818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (std::exception& e) {
52821       {
52822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52823       };
52824     } catch (...) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52827       };
52828     }
52829   }
52830   jresult = (void *)result;
52831   return jresult;
52832 }
52833
52834
52835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52836   void * jresult ;
52837   unsigned int arg1 ;
52838   Dali::Timer result;
52839
52840   arg1 = (unsigned int)jarg1;
52841   {
52842     try {
52843       result = Dali::Timer::New(arg1);
52844     } catch (std::out_of_range& e) {
52845       {
52846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52847       };
52848     } catch (std::exception& e) {
52849       {
52850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52851       };
52852     } catch (...) {
52853       {
52854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52855       };
52856     }
52857   }
52858   jresult = new Dali::Timer((const Dali::Timer &)result);
52859   return jresult;
52860 }
52861
52862
52863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52864   void * jresult ;
52865   Dali::Timer *arg1 = 0 ;
52866   Dali::Timer *result = 0 ;
52867
52868   arg1 = (Dali::Timer *)jarg1;
52869   if (!arg1) {
52870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52871     return 0;
52872   }
52873   {
52874     try {
52875       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52876     } catch (std::out_of_range& e) {
52877       {
52878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52879       };
52880     } catch (std::exception& e) {
52881       {
52882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52883       };
52884     } catch (...) {
52885       {
52886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52887       };
52888     }
52889   }
52890   jresult = (void *)result;
52891   return jresult;
52892 }
52893
52894
52895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52896   void * jresult ;
52897   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52898   Dali::Timer *arg2 = 0 ;
52899   Dali::Timer *result = 0 ;
52900
52901   arg1 = (Dali::Timer *)jarg1;
52902   arg2 = (Dali::Timer *)jarg2;
52903   if (!arg2) {
52904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52905     return 0;
52906   }
52907   {
52908     try {
52909       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52910     } catch (std::out_of_range& e) {
52911       {
52912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52913       };
52914     } catch (std::exception& e) {
52915       {
52916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52917       };
52918     } catch (...) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52921       };
52922     }
52923   }
52924   jresult = (void *)result;
52925   return jresult;
52926 }
52927
52928
52929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52930   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52931
52932   arg1 = (Dali::Timer *)jarg1;
52933   {
52934     try {
52935       delete arg1;
52936     } catch (std::out_of_range& e) {
52937       {
52938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52939       };
52940     } catch (std::exception& e) {
52941       {
52942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52943       };
52944     } catch (...) {
52945       {
52946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52947       };
52948     }
52949   }
52950 }
52951
52952
52953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52954   void * jresult ;
52955   Dali::BaseHandle arg1 ;
52956   Dali::BaseHandle *argp1 ;
52957   Dali::Timer result;
52958
52959   argp1 = (Dali::BaseHandle *)jarg1;
52960   if (!argp1) {
52961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52962     return 0;
52963   }
52964   arg1 = *argp1;
52965   {
52966     try {
52967       result = Dali::Timer::DownCast(arg1);
52968     } catch (std::out_of_range& e) {
52969       {
52970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52971       };
52972     } catch (std::exception& e) {
52973       {
52974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (...) {
52977       {
52978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52979       };
52980     }
52981   }
52982   jresult = new Dali::Timer((const Dali::Timer &)result);
52983   return jresult;
52984 }
52985
52986
52987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52988   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52989
52990   arg1 = (Dali::Timer *)jarg1;
52991   {
52992     try {
52993       (arg1)->Start();
52994     } catch (std::out_of_range& e) {
52995       {
52996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52997       };
52998     } catch (std::exception& e) {
52999       {
53000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53001       };
53002     } catch (...) {
53003       {
53004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53005       };
53006     }
53007   }
53008 }
53009
53010
53011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53012   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53013
53014   arg1 = (Dali::Timer *)jarg1;
53015   {
53016     try {
53017       (arg1)->Stop();
53018     } catch (std::out_of_range& e) {
53019       {
53020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53021       };
53022     } catch (std::exception& e) {
53023       {
53024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53025       };
53026     } catch (...) {
53027       {
53028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53029       };
53030     }
53031   }
53032 }
53033
53034
53035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53036   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53037   unsigned int arg2 ;
53038
53039   arg1 = (Dali::Timer *)jarg1;
53040   arg2 = (unsigned int)jarg2;
53041   {
53042     try {
53043       (arg1)->SetInterval(arg2);
53044     } catch (std::out_of_range& e) {
53045       {
53046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53047       };
53048     } catch (std::exception& e) {
53049       {
53050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53051       };
53052     } catch (...) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53055       };
53056     }
53057   }
53058 }
53059
53060
53061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53062   unsigned int jresult ;
53063   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53064   unsigned int result;
53065
53066   arg1 = (Dali::Timer *)jarg1;
53067   {
53068     try {
53069       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53070     } catch (std::out_of_range& e) {
53071       {
53072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53073       };
53074     } catch (std::exception& e) {
53075       {
53076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (...) {
53079       {
53080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53081       };
53082     }
53083   }
53084   jresult = result;
53085   return jresult;
53086 }
53087
53088
53089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53090   unsigned int jresult ;
53091   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53092   bool result;
53093
53094   arg1 = (Dali::Timer *)jarg1;
53095   {
53096     try {
53097       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53098     } catch (std::out_of_range& e) {
53099       {
53100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53101       };
53102     } catch (std::exception& e) {
53103       {
53104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53105       };
53106     } catch (...) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53109       };
53110     }
53111   }
53112   jresult = result;
53113   return jresult;
53114 }
53115
53116
53117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53118   void * jresult ;
53119   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53120   Dali::Timer::TimerSignalType *result = 0 ;
53121
53122   arg1 = (Dali::Timer *)jarg1;
53123   {
53124     try {
53125       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53126     } catch (std::out_of_range& e) {
53127       {
53128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53129       };
53130     } catch (std::exception& e) {
53131       {
53132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (...) {
53135       {
53136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53137       };
53138     }
53139   }
53140   jresult = (void *)result;
53141   return jresult;
53142 }
53143
53144
53145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53146   void * jresult ;
53147   Dali::DragAndDropDetector *result = 0 ;
53148
53149   {
53150     try {
53151       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53152     } catch (std::out_of_range& e) {
53153       {
53154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53155       };
53156     } catch (std::exception& e) {
53157       {
53158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53159       };
53160     } catch (...) {
53161       {
53162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53163       };
53164     }
53165   }
53166   jresult = (void *)result;
53167   return jresult;
53168 }
53169
53170
53171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53172   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53173
53174   arg1 = (Dali::DragAndDropDetector *)jarg1;
53175   {
53176     try {
53177       delete arg1;
53178     } catch (std::out_of_range& e) {
53179       {
53180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53181       };
53182     } catch (std::exception& e) {
53183       {
53184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53185       };
53186     } catch (...) {
53187       {
53188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53189       };
53190     }
53191   }
53192 }
53193
53194
53195 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53196   char * jresult ;
53197   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53198   std::string *result = 0 ;
53199
53200   arg1 = (Dali::DragAndDropDetector *)jarg1;
53201   {
53202     try {
53203       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53204     } catch (std::out_of_range& e) {
53205       {
53206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53207       };
53208     } catch (std::exception& e) {
53209       {
53210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (...) {
53213       {
53214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53215       };
53216     }
53217   }
53218   jresult = SWIG_csharp_string_callback(result->c_str());
53219   return jresult;
53220 }
53221
53222
53223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53224   void * jresult ;
53225   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53226   Dali::Vector2 result;
53227
53228   arg1 = (Dali::DragAndDropDetector *)jarg1;
53229   {
53230     try {
53231       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53232     } catch (std::out_of_range& e) {
53233       {
53234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53235       };
53236     } catch (std::exception& e) {
53237       {
53238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53239       };
53240     } catch (...) {
53241       {
53242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53243       };
53244     }
53245   }
53246   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53247   return jresult;
53248 }
53249
53250
53251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53252   void * jresult ;
53253   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53254   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53255
53256   arg1 = (Dali::DragAndDropDetector *)jarg1;
53257   {
53258     try {
53259       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53260     } catch (std::out_of_range& e) {
53261       {
53262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53263       };
53264     } catch (std::exception& e) {
53265       {
53266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53267       };
53268     } catch (...) {
53269       {
53270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53271       };
53272     }
53273   }
53274   jresult = (void *)result;
53275   return jresult;
53276 }
53277
53278
53279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53280   void * jresult ;
53281   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53282   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53283
53284   arg1 = (Dali::DragAndDropDetector *)jarg1;
53285   {
53286     try {
53287       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53288     } catch (std::out_of_range& e) {
53289       {
53290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53291       };
53292     } catch (std::exception& e) {
53293       {
53294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53295       };
53296     } catch (...) {
53297       {
53298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53299       };
53300     }
53301   }
53302   jresult = (void *)result;
53303   return jresult;
53304 }
53305
53306
53307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53308   void * jresult ;
53309   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53310   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53311
53312   arg1 = (Dali::DragAndDropDetector *)jarg1;
53313   {
53314     try {
53315       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53316     } catch (std::out_of_range& e) {
53317       {
53318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53319       };
53320     } catch (std::exception& e) {
53321       {
53322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53323       };
53324     } catch (...) {
53325       {
53326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53327       };
53328     }
53329   }
53330   jresult = (void *)result;
53331   return jresult;
53332 }
53333
53334
53335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53336   void * jresult ;
53337   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53338   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53339
53340   arg1 = (Dali::DragAndDropDetector *)jarg1;
53341   {
53342     try {
53343       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53344     } catch (std::out_of_range& e) {
53345       {
53346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53347       };
53348     } catch (std::exception& e) {
53349       {
53350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53351       };
53352     } catch (...) {
53353       {
53354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53355       };
53356     }
53357   }
53358   jresult = (void *)result;
53359   return jresult;
53360 }
53361
53362
53363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53364   void * jresult ;
53365   Dali::ApplicationExtensions *result = 0 ;
53366
53367   {
53368     try {
53369       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53370     } catch (std::out_of_range& e) {
53371       {
53372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53373       };
53374     } catch (std::exception& e) {
53375       {
53376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53377       };
53378     } catch (...) {
53379       {
53380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53381       };
53382     }
53383   }
53384   jresult = (void *)result;
53385   return jresult;
53386 }
53387
53388
53389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53390   void * jresult ;
53391   Dali::Application *arg1 = (Dali::Application *) 0 ;
53392   Dali::ApplicationExtensions *result = 0 ;
53393
53394   arg1 = (Dali::Application *)jarg1;
53395   {
53396     try {
53397       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53398     } catch (std::out_of_range& e) {
53399       {
53400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53401       };
53402     } catch (std::exception& e) {
53403       {
53404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53405       };
53406     } catch (...) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53409       };
53410     }
53411   }
53412   jresult = (void *)result;
53413   return jresult;
53414 }
53415
53416
53417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53418   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53419
53420   arg1 = (Dali::ApplicationExtensions *)jarg1;
53421   {
53422     try {
53423       delete arg1;
53424     } catch (std::out_of_range& e) {
53425       {
53426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53427       };
53428     } catch (std::exception& e) {
53429       {
53430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53431       };
53432     } catch (...) {
53433       {
53434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53435       };
53436     }
53437   }
53438 }
53439
53440
53441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53442   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53443
53444   arg1 = (Dali::ApplicationExtensions *)jarg1;
53445   {
53446     try {
53447       (arg1)->Init();
53448     } catch (std::out_of_range& e) {
53449       {
53450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53451       };
53452     } catch (std::exception& e) {
53453       {
53454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53455       };
53456     } catch (...) {
53457       {
53458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53459       };
53460     }
53461   }
53462 }
53463
53464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
53465   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53466
53467   arg1 = (Dali::ApplicationExtensions *)jarg1;
53468   {
53469     try {
53470       (arg1)->Start();
53471     } catch (std::out_of_range& e) {
53472       {
53473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53474       };
53475     } catch (std::exception& e) {
53476       {
53477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53478       };
53479     } catch (...) {
53480       {
53481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53482       };
53483     }
53484   }
53485 }
53486
53487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53488   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53489
53490   arg1 = (Dali::ApplicationExtensions *)jarg1;
53491   {
53492     try {
53493       (arg1)->Terminate();
53494     } catch (std::out_of_range& e) {
53495       {
53496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53497       };
53498     } catch (std::exception& e) {
53499       {
53500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53501       };
53502     } catch (...) {
53503       {
53504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53505       };
53506     }
53507   }
53508 }
53509
53510
53511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53512   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53513
53514   arg1 = (Dali::ApplicationExtensions *)jarg1;
53515   {
53516     try {
53517       (arg1)->Pause();
53518     } catch (std::out_of_range& e) {
53519       {
53520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53521       };
53522     } catch (std::exception& e) {
53523       {
53524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53525       };
53526     } catch (...) {
53527       {
53528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53529       };
53530     }
53531   }
53532 }
53533
53534
53535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53536   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53537
53538   arg1 = (Dali::ApplicationExtensions *)jarg1;
53539   {
53540     try {
53541       (arg1)->Resume();
53542     } catch (std::out_of_range& e) {
53543       {
53544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53545       };
53546     } catch (std::exception& e) {
53547       {
53548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53549       };
53550     } catch (...) {
53551       {
53552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53553       };
53554     }
53555   }
53556 }
53557
53558
53559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53560   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53561
53562   arg1 = (Dali::ApplicationExtensions *)jarg1;
53563   {
53564     try {
53565       (arg1)->LanguageChange();
53566     } catch (std::out_of_range& e) {
53567       {
53568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53569       };
53570     } catch (std::exception& e) {
53571       {
53572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53573       };
53574     } catch (...) {
53575       {
53576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53577       };
53578     }
53579   }
53580 }
53581
53582
53583
53584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
53585   unsigned int jresult ;
53586   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53587   bool result;
53588
53589   arg1 = (Dali::Signal< bool () > *)jarg1;
53590   {
53591     try {
53592       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
53593     } catch (std::out_of_range& e) {
53594       {
53595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53596       };
53597     } catch (std::exception& e) {
53598       {
53599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53600       };
53601     } catch (...) {
53602       {
53603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53604       };
53605     }
53606   }
53607   jresult = result;
53608   return jresult;
53609 }
53610
53611
53612 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
53613   unsigned long jresult ;
53614   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53615   std::size_t result;
53616
53617   arg1 = (Dali::Signal< bool () > *)jarg1;
53618   {
53619     try {
53620       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
53621     } catch (std::out_of_range& e) {
53622       {
53623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53624       };
53625     } catch (std::exception& e) {
53626       {
53627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53628       };
53629     } catch (...) {
53630       {
53631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53632       };
53633     }
53634   }
53635   jresult = (unsigned long)result;
53636   return jresult;
53637 }
53638
53639
53640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
53641   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53642   bool (*arg2)() = (bool (*)()) 0 ;
53643
53644   arg1 = (Dali::Signal< bool () > *)jarg1;
53645   arg2 = (bool (*)())jarg2;
53646   {
53647     try {
53648       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
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_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
53667   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53668   bool (*arg2)() = (bool (*)()) 0 ;
53669
53670   arg1 = (Dali::Signal< bool () > *)jarg1;
53671   arg2 = (bool (*)())jarg2;
53672   {
53673     try {
53674       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
53675     } catch (std::out_of_range& e) {
53676       {
53677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53678       };
53679     } catch (std::exception& e) {
53680       {
53681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53682       };
53683     } catch (...) {
53684       {
53685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53686       };
53687     }
53688   }
53689 }
53690
53691
53692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
53693   unsigned int jresult ;
53694   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53695   bool result;
53696
53697   arg1 = (Dali::Signal< bool () > *)jarg1;
53698   {
53699     try {
53700       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
53701     } catch (std::out_of_range& e) {
53702       {
53703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53704       };
53705     } catch (std::exception& e) {
53706       {
53707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53708       };
53709     } catch (...) {
53710       {
53711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53712       };
53713     }
53714   }
53715   jresult = result;
53716   return jresult;
53717 }
53718
53719
53720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
53721   void * jresult ;
53722   Dali::Signal< bool () > *result = 0 ;
53723
53724   {
53725     try {
53726       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
53727     } catch (std::out_of_range& e) {
53728       {
53729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53730       };
53731     } catch (std::exception& e) {
53732       {
53733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53734       };
53735     } catch (...) {
53736       {
53737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53738       };
53739     }
53740   }
53741   jresult = (void *)result;
53742   return jresult;
53743 }
53744
53745
53746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
53747   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53748
53749   arg1 = (Dali::Signal< bool () > *)jarg1;
53750   {
53751     try {
53752       delete arg1;
53753     } catch (std::out_of_range& e) {
53754       {
53755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53756       };
53757     } catch (std::exception& e) {
53758       {
53759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53760       };
53761     } catch (...) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53764       };
53765     }
53766   }
53767 }
53768
53769
53770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
53771   int jresult ;
53772   int result;
53773
53774   {
53775     try {
53776       result = (int)Dali::Toolkit::Visual::Property::TYPE;
53777     } catch (std::out_of_range& e) {
53778       {
53779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53780       };
53781     } catch (std::exception& e) {
53782       {
53783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53784       };
53785     } catch (...) {
53786       {
53787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53788       };
53789     }
53790   }
53791   jresult = (int)result;
53792   return jresult;
53793 }
53794
53795
53796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
53797   int jresult ;
53798   int result;
53799
53800   {
53801     try {
53802       result = (int)Dali::Toolkit::Visual::Property::SHADER;
53803     } catch (std::out_of_range& e) {
53804       {
53805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53806       };
53807     } catch (std::exception& e) {
53808       {
53809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53810       };
53811     } catch (...) {
53812       {
53813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53814       };
53815     }
53816   }
53817   jresult = (int)result;
53818   return jresult;
53819 }
53820
53821
53822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
53823   int jresult ;
53824   int result;
53825
53826   {
53827     try {
53828       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
53829     } catch (std::out_of_range& e) {
53830       {
53831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53832       };
53833     } catch (std::exception& e) {
53834       {
53835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53836       };
53837     } catch (...) {
53838       {
53839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53840       };
53841     }
53842   }
53843   jresult = (int)result;
53844   return jresult;
53845 }
53846
53847
53848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
53849   int jresult ;
53850   int result;
53851
53852   {
53853     try {
53854       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
53855     } catch (std::out_of_range& e) {
53856       {
53857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53858       };
53859     } catch (std::exception& e) {
53860       {
53861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53862       };
53863     } catch (...) {
53864       {
53865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53866       };
53867     }
53868   }
53869   jresult = (int)result;
53870   return jresult;
53871 }
53872
53873
53874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
53875   int jresult ;
53876   int result;
53877
53878   {
53879     try {
53880       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
53881     } catch (std::out_of_range& e) {
53882       {
53883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53884       };
53885     } catch (std::exception& e) {
53886       {
53887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53888       };
53889     } catch (...) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53892       };
53893     }
53894   }
53895   jresult = (int)result;
53896   return jresult;
53897 }
53898
53899
53900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
53901   int jresult ;
53902   int result;
53903
53904   {
53905     try {
53906       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
53907     } catch (std::out_of_range& e) {
53908       {
53909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53910       };
53911     } catch (std::exception& e) {
53912       {
53913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53914       };
53915     } catch (...) {
53916       {
53917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53918       };
53919     }
53920   }
53921   jresult = (int)result;
53922   return jresult;
53923 }
53924
53925
53926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
53927   int jresult ;
53928   int result;
53929
53930   {
53931     try {
53932       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
53933     } catch (std::out_of_range& e) {
53934       {
53935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (std::exception& e) {
53938       {
53939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53940       };
53941     } catch (...) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53944       };
53945     }
53946   }
53947   jresult = (int)result;
53948   return jresult;
53949 }
53950
53951
53952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
53953   int jresult ;
53954   int result;
53955
53956   {
53957     try {
53958       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
53959     } catch (std::out_of_range& e) {
53960       {
53961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53962       };
53963     } catch (std::exception& e) {
53964       {
53965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53966       };
53967     } catch (...) {
53968       {
53969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53970       };
53971     }
53972   }
53973   jresult = (int)result;
53974   return jresult;
53975 }
53976
53977
53978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
53979   int jresult ;
53980   int result;
53981
53982   {
53983     try {
53984       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
53985     } catch (std::out_of_range& e) {
53986       {
53987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53988       };
53989     } catch (std::exception& e) {
53990       {
53991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53992       };
53993     } catch (...) {
53994       {
53995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53996       };
53997     }
53998   }
53999   jresult = (int)result;
54000   return jresult;
54001 }
54002
54003
54004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
54005   int jresult ;
54006   int result;
54007
54008   {
54009     try {
54010       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
54011     } catch (std::out_of_range& e) {
54012       {
54013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54014       };
54015     } catch (std::exception& e) {
54016       {
54017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54018       };
54019     } catch (...) {
54020       {
54021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54022       };
54023     }
54024   }
54025   jresult = (int)result;
54026   return jresult;
54027 }
54028
54029
54030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
54031   int jresult ;
54032   int result;
54033
54034   {
54035     try {
54036       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
54037     } catch (std::out_of_range& e) {
54038       {
54039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54040       };
54041     } catch (std::exception& e) {
54042       {
54043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54044       };
54045     } catch (...) {
54046       {
54047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54048       };
54049     }
54050   }
54051   jresult = (int)result;
54052   return jresult;
54053 }
54054
54055
54056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
54057   int jresult ;
54058   int result;
54059
54060   {
54061     try {
54062       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
54063     } catch (std::out_of_range& e) {
54064       {
54065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54066       };
54067     } catch (std::exception& e) {
54068       {
54069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54070       };
54071     } catch (...) {
54072       {
54073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54074       };
54075     }
54076   }
54077   jresult = (int)result;
54078   return jresult;
54079 }
54080
54081
54082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
54083   int jresult ;
54084   int result;
54085
54086   {
54087     try {
54088       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
54089     } catch (std::out_of_range& e) {
54090       {
54091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54092       };
54093     } catch (std::exception& e) {
54094       {
54095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54096       };
54097     } catch (...) {
54098       {
54099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54100       };
54101     }
54102   }
54103   jresult = (int)result;
54104   return jresult;
54105 }
54106
54107
54108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
54109   int jresult ;
54110   int result;
54111
54112   {
54113     try {
54114       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
54115     } catch (std::out_of_range& e) {
54116       {
54117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54118       };
54119     } catch (std::exception& e) {
54120       {
54121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54122       };
54123     } catch (...) {
54124       {
54125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54126       };
54127     }
54128   }
54129   jresult = (int)result;
54130   return jresult;
54131 }
54132
54133
54134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
54135   int jresult ;
54136   int result;
54137
54138   {
54139     try {
54140       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
54141     } catch (std::out_of_range& e) {
54142       {
54143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54144       };
54145     } catch (std::exception& e) {
54146       {
54147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54148       };
54149     } catch (...) {
54150       {
54151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54152       };
54153     }
54154   }
54155   jresult = (int)result;
54156   return jresult;
54157 }
54158
54159
54160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
54161   int jresult ;
54162   int result;
54163
54164   {
54165     try {
54166       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
54167     } catch (std::out_of_range& e) {
54168       {
54169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54170       };
54171     } catch (std::exception& e) {
54172       {
54173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54174       };
54175     } catch (...) {
54176       {
54177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54178       };
54179     }
54180   }
54181   jresult = (int)result;
54182   return jresult;
54183 }
54184
54185
54186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
54187   int jresult ;
54188   int result;
54189
54190   {
54191     try {
54192       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
54193     } catch (std::out_of_range& e) {
54194       {
54195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54196       };
54197     } catch (std::exception& e) {
54198       {
54199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54200       };
54201     } catch (...) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54204       };
54205     }
54206   }
54207   jresult = (int)result;
54208   return jresult;
54209 }
54210
54211
54212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
54213   int jresult ;
54214   int result;
54215
54216   {
54217     try {
54218       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
54219     } catch (std::out_of_range& e) {
54220       {
54221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54222       };
54223     } catch (std::exception& e) {
54224       {
54225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54226       };
54227     } catch (...) {
54228       {
54229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54230       };
54231     }
54232   }
54233   jresult = (int)result;
54234   return jresult;
54235 }
54236
54237
54238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
54239   int jresult ;
54240   int result;
54241
54242   {
54243     try {
54244       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
54245     } catch (std::out_of_range& e) {
54246       {
54247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (std::exception& e) {
54250       {
54251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (...) {
54254       {
54255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54256       };
54257     }
54258   }
54259   jresult = (int)result;
54260   return jresult;
54261 }
54262
54263
54264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
54265   int jresult ;
54266   int result;
54267
54268   {
54269     try {
54270       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
54271     } catch (std::out_of_range& e) {
54272       {
54273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54274       };
54275     } catch (std::exception& e) {
54276       {
54277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54278       };
54279     } catch (...) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54282       };
54283     }
54284   }
54285   jresult = (int)result;
54286   return jresult;
54287 }
54288
54289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
54290   int jresult ;
54291   int result;
54292
54293   {
54294     try {
54295       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
54296     } catch (std::out_of_range& e) {
54297       {
54298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54299       };
54300     } catch (std::exception& e) {
54301       {
54302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54303       };
54304     } catch (...) {
54305       {
54306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54307       };
54308     }
54309   }
54310   jresult = (int)result;
54311   return jresult;
54312 }
54313
54314
54315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
54316   int jresult ;
54317   int result;
54318
54319   {
54320     try {
54321       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
54322     } catch (std::out_of_range& e) {
54323       {
54324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54325       };
54326     } catch (std::exception& e) {
54327       {
54328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54329       };
54330     } catch (...) {
54331       {
54332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54333       };
54334     }
54335   }
54336   jresult = (int)result;
54337   return jresult;
54338 }
54339
54340
54341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
54342   int jresult ;
54343   int result;
54344
54345   {
54346     try {
54347       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
54348     } catch (std::out_of_range& e) {
54349       {
54350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54351       };
54352     } catch (std::exception& e) {
54353       {
54354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54355       };
54356     } catch (...) {
54357       {
54358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54359       };
54360     }
54361   }
54362   jresult = (int)result;
54363   return jresult;
54364 }
54365
54366
54367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
54368   int jresult ;
54369   int result;
54370
54371   {
54372     try {
54373       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
54374     } catch (std::out_of_range& e) {
54375       {
54376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54377       };
54378     } catch (std::exception& e) {
54379       {
54380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54381       };
54382     } catch (...) {
54383       {
54384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54385       };
54386     }
54387   }
54388   jresult = (int)result;
54389   return jresult;
54390 }
54391
54392
54393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
54394   int jresult ;
54395   int result;
54396
54397   {
54398     try {
54399       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
54400     } catch (std::out_of_range& e) {
54401       {
54402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54403       };
54404     } catch (std::exception& e) {
54405       {
54406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54407       };
54408     } catch (...) {
54409       {
54410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54411       };
54412     }
54413   }
54414   jresult = (int)result;
54415   return jresult;
54416 }
54417
54418
54419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
54420   int jresult ;
54421   int result;
54422
54423   {
54424     try {
54425       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
54426     } catch (std::out_of_range& e) {
54427       {
54428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54429       };
54430     } catch (std::exception& e) {
54431       {
54432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54433       };
54434     } catch (...) {
54435       {
54436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54437       };
54438     }
54439   }
54440   jresult = (int)result;
54441   return jresult;
54442 }
54443
54444
54445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
54446   int jresult ;
54447   int result;
54448
54449   {
54450     try {
54451       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
54452     } catch (std::out_of_range& e) {
54453       {
54454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54455       };
54456     } catch (std::exception& e) {
54457       {
54458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54459       };
54460     } catch (...) {
54461       {
54462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54463       };
54464     }
54465   }
54466   jresult = (int)result;
54467   return jresult;
54468 }
54469
54470
54471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
54472   int jresult ;
54473   int result;
54474
54475   {
54476     try {
54477       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
54478     } catch (std::out_of_range& e) {
54479       {
54480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (std::exception& e) {
54483       {
54484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54485       };
54486     } catch (...) {
54487       {
54488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54489       };
54490     }
54491   }
54492   jresult = (int)result;
54493   return jresult;
54494 }
54495
54496
54497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
54498   int jresult ;
54499   int result;
54500
54501   {
54502     try {
54503       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
54504     } catch (std::out_of_range& e) {
54505       {
54506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54507       };
54508     } catch (std::exception& e) {
54509       {
54510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54511       };
54512     } catch (...) {
54513       {
54514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54515       };
54516     }
54517   }
54518   jresult = (int)result;
54519   return jresult;
54520 }
54521
54522
54523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
54524   int jresult ;
54525   int result;
54526
54527   {
54528     try {
54529       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
54530     } catch (std::out_of_range& e) {
54531       {
54532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54533       };
54534     } catch (std::exception& e) {
54535       {
54536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54537       };
54538     } catch (...) {
54539       {
54540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54541       };
54542     }
54543   }
54544   jresult = (int)result;
54545   return jresult;
54546 }
54547
54548
54549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
54550   int jresult ;
54551   int result;
54552
54553   {
54554     try {
54555       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
54556     } catch (std::out_of_range& e) {
54557       {
54558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54559       };
54560     } catch (std::exception& e) {
54561       {
54562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54563       };
54564     } catch (...) {
54565       {
54566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54567       };
54568     }
54569   }
54570   jresult = (int)result;
54571   return jresult;
54572 }
54573
54574
54575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
54576   int jresult ;
54577   int result;
54578
54579   {
54580     try {
54581       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
54582     } catch (std::out_of_range& e) {
54583       {
54584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54585       };
54586     } catch (std::exception& e) {
54587       {
54588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54589       };
54590     } catch (...) {
54591       {
54592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54593       };
54594     }
54595   }
54596   jresult = (int)result;
54597   return jresult;
54598 }
54599
54600
54601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
54602   int jresult ;
54603   int result;
54604
54605   {
54606     try {
54607       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
54608     } catch (std::out_of_range& e) {
54609       {
54610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54611       };
54612     } catch (std::exception& e) {
54613       {
54614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54615       };
54616     } catch (...) {
54617       {
54618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54619       };
54620     }
54621   }
54622   jresult = (int)result;
54623   return jresult;
54624 }
54625
54626
54627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
54628   int jresult ;
54629   int result;
54630
54631   {
54632     try {
54633       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
54634     } catch (std::out_of_range& e) {
54635       {
54636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54637       };
54638     } catch (std::exception& e) {
54639       {
54640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54641       };
54642     } catch (...) {
54643       {
54644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54645       };
54646     }
54647   }
54648   jresult = (int)result;
54649   return jresult;
54650 }
54651
54652
54653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
54654   int jresult ;
54655   int result;
54656
54657   {
54658     try {
54659       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
54660     } catch (std::out_of_range& e) {
54661       {
54662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54663       };
54664     } catch (std::exception& e) {
54665       {
54666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54667       };
54668     } catch (...) {
54669       {
54670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54671       };
54672     }
54673   }
54674   jresult = (int)result;
54675   return jresult;
54676 }
54677
54678
54679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
54680   int jresult ;
54681   int result;
54682
54683   {
54684     try {
54685       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (...) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54697       };
54698     }
54699   }
54700   jresult = (int)result;
54701   return jresult;
54702 }
54703
54704
54705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
54706   int jresult ;
54707   int result;
54708
54709   {
54710     try {
54711       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
54712     } catch (std::out_of_range& e) {
54713       {
54714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54715       };
54716     } catch (std::exception& e) {
54717       {
54718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54719       };
54720     } catch (...) {
54721       {
54722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54723       };
54724     }
54725   }
54726   jresult = (int)result;
54727   return jresult;
54728 }
54729
54730
54731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
54732   int jresult ;
54733   int result;
54734
54735   {
54736     try {
54737       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
54738     } catch (std::out_of_range& e) {
54739       {
54740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54741       };
54742     } catch (std::exception& e) {
54743       {
54744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54745       };
54746     } catch (...) {
54747       {
54748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54749       };
54750     }
54751   }
54752   jresult = (int)result;
54753   return jresult;
54754 }
54755
54756
54757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
54758   int jresult ;
54759   int result;
54760
54761   {
54762     try {
54763       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
54764     } catch (std::out_of_range& e) {
54765       {
54766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54767       };
54768     } catch (std::exception& e) {
54769       {
54770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54771       };
54772     } catch (...) {
54773       {
54774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54775       };
54776     }
54777   }
54778   jresult = (int)result;
54779   return jresult;
54780 }
54781
54782
54783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
54784   int jresult ;
54785   int result;
54786
54787   {
54788     try {
54789       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
54790     } catch (std::out_of_range& e) {
54791       {
54792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54793       };
54794     } catch (std::exception& e) {
54795       {
54796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54797       };
54798     } catch (...) {
54799       {
54800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54801       };
54802     }
54803   }
54804   jresult = (int)result;
54805   return jresult;
54806 }
54807
54808
54809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
54810   int jresult ;
54811   int result;
54812
54813   {
54814     try {
54815       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
54816     } catch (std::out_of_range& e) {
54817       {
54818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54819       };
54820     } catch (std::exception& e) {
54821       {
54822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54823       };
54824     } catch (...) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54827       };
54828     }
54829   }
54830   jresult = (int)result;
54831   return jresult;
54832 }
54833
54834
54835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
54836   int jresult ;
54837   int result;
54838
54839   {
54840     try {
54841       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
54842     } catch (std::out_of_range& e) {
54843       {
54844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54845       };
54846     } catch (std::exception& e) {
54847       {
54848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54849       };
54850     } catch (...) {
54851       {
54852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54853       };
54854     }
54855   }
54856   jresult = (int)result;
54857   return jresult;
54858 }
54859
54860
54861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
54862   int jresult ;
54863   int result;
54864
54865   {
54866     try {
54867       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
54868     } catch (std::out_of_range& e) {
54869       {
54870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54871       };
54872     } catch (std::exception& e) {
54873       {
54874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54875       };
54876     } catch (...) {
54877       {
54878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54879       };
54880     }
54881   }
54882   jresult = (int)result;
54883   return jresult;
54884 }
54885
54886
54887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
54888   int jresult ;
54889   int result;
54890
54891   {
54892     try {
54893       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
54894     } catch (std::out_of_range& e) {
54895       {
54896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54897       };
54898     } catch (std::exception& e) {
54899       {
54900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54901       };
54902     } catch (...) {
54903       {
54904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54905       };
54906     }
54907   }
54908   jresult = (int)result;
54909   return jresult;
54910 }
54911
54912
54913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
54914   int jresult ;
54915   int result;
54916
54917   {
54918     try {
54919       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
54920     } catch (std::out_of_range& e) {
54921       {
54922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54923       };
54924     } catch (std::exception& e) {
54925       {
54926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54927       };
54928     } catch (...) {
54929       {
54930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54931       };
54932     }
54933   }
54934   jresult = (int)result;
54935   return jresult;
54936 }
54937
54938
54939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
54940   int jresult ;
54941   int result;
54942
54943   {
54944     try {
54945       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
54946     } catch (std::out_of_range& e) {
54947       {
54948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54949       };
54950     } catch (std::exception& e) {
54951       {
54952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54953       };
54954     } catch (...) {
54955       {
54956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54957       };
54958     }
54959   }
54960   jresult = (int)result;
54961   return jresult;
54962 }
54963
54964
54965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
54966   int jresult ;
54967   int result;
54968
54969   {
54970     try {
54971       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
54972     } catch (std::out_of_range& e) {
54973       {
54974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54975       };
54976     } catch (std::exception& e) {
54977       {
54978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54979       };
54980     } catch (...) {
54981       {
54982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54983       };
54984     }
54985   }
54986   jresult = (int)result;
54987   return jresult;
54988 }
54989
54990
54991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
54992   int jresult ;
54993   int result;
54994
54995   {
54996     try {
54997       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
54998     } catch (std::out_of_range& e) {
54999       {
55000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55001       };
55002     } catch (std::exception& e) {
55003       {
55004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55005       };
55006     } catch (...) {
55007       {
55008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55009       };
55010     }
55011   }
55012   jresult = (int)result;
55013   return jresult;
55014 }
55015
55016
55017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
55018   int jresult ;
55019   int result;
55020
55021   {
55022     try {
55023       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
55024     } catch (std::out_of_range& e) {
55025       {
55026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55027       };
55028     } catch (std::exception& e) {
55029       {
55030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55031       };
55032     } catch (...) {
55033       {
55034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55035       };
55036     }
55037   }
55038   jresult = (int)result;
55039   return jresult;
55040 }
55041
55042
55043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
55044   int jresult ;
55045   int result;
55046
55047   {
55048     try {
55049       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
55050     } catch (std::out_of_range& e) {
55051       {
55052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55053       };
55054     } catch (std::exception& e) {
55055       {
55056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55057       };
55058     } catch (...) {
55059       {
55060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55061       };
55062     }
55063   }
55064   jresult = (int)result;
55065   return jresult;
55066 }
55067
55068
55069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
55070   int jresult ;
55071   int result;
55072
55073   {
55074     try {
55075       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
55076     } catch (std::out_of_range& e) {
55077       {
55078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55079       };
55080     } catch (std::exception& e) {
55081       {
55082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55083       };
55084     } catch (...) {
55085       {
55086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55087       };
55088     }
55089   }
55090   jresult = (int)result;
55091   return jresult;
55092 }
55093
55094
55095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
55096   int jresult ;
55097   int result;
55098
55099   {
55100     try {
55101       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
55102     } catch (std::out_of_range& e) {
55103       {
55104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55105       };
55106     } catch (std::exception& e) {
55107       {
55108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55109       };
55110     } catch (...) {
55111       {
55112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55113       };
55114     }
55115   }
55116   jresult = (int)result;
55117   return jresult;
55118 }
55119
55120
55121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
55122   int jresult ;
55123   int result;
55124
55125   {
55126     try {
55127       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
55128     } catch (std::out_of_range& e) {
55129       {
55130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55131       };
55132     } catch (std::exception& e) {
55133       {
55134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55135       };
55136     } catch (...) {
55137       {
55138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55139       };
55140     }
55141   }
55142   jresult = (int)result;
55143   return jresult;
55144 }
55145
55146
55147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
55148   int jresult ;
55149   int result;
55150
55151   {
55152     try {
55153       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
55154     } catch (std::out_of_range& e) {
55155       {
55156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55157       };
55158     } catch (std::exception& e) {
55159       {
55160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55161       };
55162     } catch (...) {
55163       {
55164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55165       };
55166     }
55167   }
55168   jresult = (int)result;
55169   return jresult;
55170 }
55171
55172
55173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
55174   int jresult ;
55175   int result;
55176
55177   {
55178     try {
55179       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
55180     } catch (std::out_of_range& e) {
55181       {
55182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55183       };
55184     } catch (std::exception& e) {
55185       {
55186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55187       };
55188     } catch (...) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55191       };
55192     }
55193   }
55194   jresult = (int)result;
55195   return jresult;
55196 }
55197
55198
55199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
55200   int jresult ;
55201   int result;
55202
55203   {
55204     try {
55205       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
55206     } catch (std::out_of_range& e) {
55207       {
55208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55209       };
55210     } catch (std::exception& e) {
55211       {
55212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55213       };
55214     } catch (...) {
55215       {
55216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55217       };
55218     }
55219   }
55220   jresult = (int)result;
55221   return jresult;
55222 }
55223
55224
55225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
55226   int jresult ;
55227   int result;
55228
55229   {
55230     try {
55231       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
55232     } catch (std::out_of_range& e) {
55233       {
55234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55235       };
55236     } catch (std::exception& e) {
55237       {
55238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55239       };
55240     } catch (...) {
55241       {
55242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55243       };
55244     }
55245   }
55246   jresult = (int)result;
55247   return jresult;
55248 }
55249
55250
55251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
55252   int jresult ;
55253   int result;
55254
55255   {
55256     try {
55257       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
55258     } catch (std::out_of_range& e) {
55259       {
55260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55261       };
55262     } catch (std::exception& e) {
55263       {
55264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55265       };
55266     } catch (...) {
55267       {
55268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55269       };
55270     }
55271   }
55272   jresult = (int)result;
55273   return jresult;
55274 }
55275
55276
55277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
55278   void * jresult ;
55279   Dali::Toolkit::Builder *result = 0 ;
55280
55281   {
55282     try {
55283       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
55284     } catch (std::out_of_range& e) {
55285       {
55286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55287       };
55288     } catch (std::exception& e) {
55289       {
55290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55291       };
55292     } catch (...) {
55293       {
55294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55295       };
55296     }
55297   }
55298   jresult = (void *)result;
55299   return jresult;
55300 }
55301
55302
55303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
55304   void * jresult ;
55305   Dali::Toolkit::Builder result;
55306
55307   {
55308     try {
55309       result = Dali::Toolkit::Builder::New();
55310     } catch (std::out_of_range& e) {
55311       {
55312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55313       };
55314     } catch (std::exception& e) {
55315       {
55316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55317       };
55318     } catch (...) {
55319       {
55320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55321       };
55322     }
55323   }
55324   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
55325   return jresult;
55326 }
55327
55328
55329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
55330   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55331
55332   arg1 = (Dali::Toolkit::Builder *)jarg1;
55333   {
55334     try {
55335       delete arg1;
55336     } catch (std::out_of_range& e) {
55337       {
55338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55339       };
55340     } catch (std::exception& e) {
55341       {
55342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55347       };
55348     }
55349   }
55350 }
55351
55352
55353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
55354   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55355   std::string *arg2 = 0 ;
55356   Dali::Toolkit::Builder::UIFormat arg3 ;
55357
55358   arg1 = (Dali::Toolkit::Builder *)jarg1;
55359   if (!jarg2) {
55360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55361     return ;
55362   }
55363   std::string arg2_str(jarg2);
55364   arg2 = &arg2_str;
55365   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
55366   {
55367     try {
55368       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
55369     } catch (std::out_of_range& e) {
55370       {
55371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55372       };
55373     } catch (std::exception& e) {
55374       {
55375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55376       };
55377     } catch (...) {
55378       {
55379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55380       };
55381     }
55382   }
55383
55384   //argout typemap for const std::string&
55385
55386 }
55387
55388
55389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
55390   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55391   std::string *arg2 = 0 ;
55392
55393   arg1 = (Dali::Toolkit::Builder *)jarg1;
55394   if (!jarg2) {
55395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55396     return ;
55397   }
55398   std::string arg2_str(jarg2);
55399   arg2 = &arg2_str;
55400   {
55401     try {
55402       (arg1)->LoadFromString((std::string const &)*arg2);
55403     } catch (std::out_of_range& e) {
55404       {
55405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55406       };
55407     } catch (std::exception& e) {
55408       {
55409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55410       };
55411     } catch (...) {
55412       {
55413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55414       };
55415     }
55416   }
55417
55418   //argout typemap for const std::string&
55419
55420 }
55421
55422
55423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
55424   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55425   Dali::Property::Map *arg2 = 0 ;
55426
55427   arg1 = (Dali::Toolkit::Builder *)jarg1;
55428   arg2 = (Dali::Property::Map *)jarg2;
55429   if (!arg2) {
55430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55431     return ;
55432   }
55433   {
55434     try {
55435       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
55436     } catch (std::out_of_range& e) {
55437       {
55438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55439       };
55440     } catch (std::exception& e) {
55441       {
55442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55443       };
55444     } catch (...) {
55445       {
55446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55447       };
55448     }
55449   }
55450 }
55451
55452
55453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
55454   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55455   std::string *arg2 = 0 ;
55456   Dali::Property::Value *arg3 = 0 ;
55457
55458   arg1 = (Dali::Toolkit::Builder *)jarg1;
55459   if (!jarg2) {
55460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55461     return ;
55462   }
55463   std::string arg2_str(jarg2);
55464   arg2 = &arg2_str;
55465   arg3 = (Dali::Property::Value *)jarg3;
55466   if (!arg3) {
55467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
55468     return ;
55469   }
55470   {
55471     try {
55472       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
55473     } catch (std::out_of_range& e) {
55474       {
55475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55476       };
55477     } catch (std::exception& e) {
55478       {
55479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55480       };
55481     } catch (...) {
55482       {
55483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55484       };
55485     }
55486   }
55487
55488   //argout typemap for const std::string&
55489
55490 }
55491
55492
55493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
55494   void * jresult ;
55495   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55496   Dali::Property::Map *result = 0 ;
55497
55498   arg1 = (Dali::Toolkit::Builder *)jarg1;
55499   {
55500     try {
55501       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
55502     } catch (std::out_of_range& e) {
55503       {
55504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55505       };
55506     } catch (std::exception& e) {
55507       {
55508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (...) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55513       };
55514     }
55515   }
55516   jresult = (void *)result;
55517   return jresult;
55518 }
55519
55520
55521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
55522   void * jresult ;
55523   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55524   std::string *arg2 = 0 ;
55525   Dali::Property::Value *result = 0 ;
55526
55527   arg1 = (Dali::Toolkit::Builder *)jarg1;
55528   if (!jarg2) {
55529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55530     return 0;
55531   }
55532   std::string arg2_str(jarg2);
55533   arg2 = &arg2_str;
55534   {
55535     try {
55536       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
55537     } catch (std::out_of_range& e) {
55538       {
55539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55540       };
55541     } catch (std::exception& e) {
55542       {
55543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55548       };
55549     }
55550   }
55551   jresult = (void *)result;
55552
55553   //argout typemap for const std::string&
55554
55555   return jresult;
55556 }
55557
55558
55559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
55560   void * jresult ;
55561   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55562   std::string *arg2 = 0 ;
55563   Dali::Animation result;
55564
55565   arg1 = (Dali::Toolkit::Builder *)jarg1;
55566   if (!jarg2) {
55567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55568     return 0;
55569   }
55570   std::string arg2_str(jarg2);
55571   arg2 = &arg2_str;
55572   {
55573     try {
55574       result = (arg1)->CreateAnimation((std::string const &)*arg2);
55575     } catch (std::out_of_range& e) {
55576       {
55577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55578       };
55579     } catch (std::exception& e) {
55580       {
55581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55582       };
55583     } catch (...) {
55584       {
55585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55586       };
55587     }
55588   }
55589   jresult = new Dali::Animation((const Dali::Animation &)result);
55590
55591   //argout typemap for const std::string&
55592
55593   return jresult;
55594 }
55595
55596
55597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
55598   void * jresult ;
55599   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55600   std::string *arg2 = 0 ;
55601   Dali::Property::Map *arg3 = 0 ;
55602   Dali::Animation result;
55603
55604   arg1 = (Dali::Toolkit::Builder *)jarg1;
55605   if (!jarg2) {
55606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55607     return 0;
55608   }
55609   std::string arg2_str(jarg2);
55610   arg2 = &arg2_str;
55611   arg3 = (Dali::Property::Map *)jarg3;
55612   if (!arg3) {
55613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55614     return 0;
55615   }
55616   {
55617     try {
55618       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
55619     } catch (std::out_of_range& e) {
55620       {
55621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55622       };
55623     } catch (std::exception& e) {
55624       {
55625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55626       };
55627     } catch (...) {
55628       {
55629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55630       };
55631     }
55632   }
55633   jresult = new Dali::Animation((const Dali::Animation &)result);
55634
55635   //argout typemap for const std::string&
55636
55637   return jresult;
55638 }
55639
55640
55641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
55642   void * jresult ;
55643   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55644   std::string *arg2 = 0 ;
55645   Dali::Actor arg3 ;
55646   Dali::Actor *argp3 ;
55647   Dali::Animation result;
55648
55649   arg1 = (Dali::Toolkit::Builder *)jarg1;
55650   if (!jarg2) {
55651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55652     return 0;
55653   }
55654   std::string arg2_str(jarg2);
55655   arg2 = &arg2_str;
55656   argp3 = (Dali::Actor *)jarg3;
55657   if (!argp3) {
55658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55659     return 0;
55660   }
55661   arg3 = *argp3;
55662   {
55663     try {
55664       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
55665     } catch (std::out_of_range& e) {
55666       {
55667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55668       };
55669     } catch (std::exception& e) {
55670       {
55671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55672       };
55673     } catch (...) {
55674       {
55675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55676       };
55677     }
55678   }
55679   jresult = new Dali::Animation((const Dali::Animation &)result);
55680
55681   //argout typemap for const std::string&
55682
55683   return jresult;
55684 }
55685
55686
55687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
55688   void * jresult ;
55689   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55690   std::string *arg2 = 0 ;
55691   Dali::Property::Map *arg3 = 0 ;
55692   Dali::Actor arg4 ;
55693   Dali::Actor *argp4 ;
55694   Dali::Animation result;
55695
55696   arg1 = (Dali::Toolkit::Builder *)jarg1;
55697   if (!jarg2) {
55698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55699     return 0;
55700   }
55701   std::string arg2_str(jarg2);
55702   arg2 = &arg2_str;
55703   arg3 = (Dali::Property::Map *)jarg3;
55704   if (!arg3) {
55705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55706     return 0;
55707   }
55708   argp4 = (Dali::Actor *)jarg4;
55709   if (!argp4) {
55710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55711     return 0;
55712   }
55713   arg4 = *argp4;
55714   {
55715     try {
55716       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
55717     } catch (std::out_of_range& e) {
55718       {
55719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55720       };
55721     } catch (std::exception& e) {
55722       {
55723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55724       };
55725     } catch (...) {
55726       {
55727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55728       };
55729     }
55730   }
55731   jresult = new Dali::Animation((const Dali::Animation &)result);
55732
55733   //argout typemap for const std::string&
55734
55735   return jresult;
55736 }
55737
55738
55739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
55740   void * jresult ;
55741   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55742   std::string *arg2 = 0 ;
55743   Dali::BaseHandle result;
55744
55745   arg1 = (Dali::Toolkit::Builder *)jarg1;
55746   if (!jarg2) {
55747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55748     return 0;
55749   }
55750   std::string arg2_str(jarg2);
55751   arg2 = &arg2_str;
55752   {
55753     try {
55754       result = (arg1)->Create((std::string const &)*arg2);
55755     } catch (std::out_of_range& e) {
55756       {
55757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55758       };
55759     } catch (std::exception& e) {
55760       {
55761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55762       };
55763     } catch (...) {
55764       {
55765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55766       };
55767     }
55768   }
55769   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55770
55771   //argout typemap for const std::string&
55772
55773   return jresult;
55774 }
55775
55776
55777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
55778   void * jresult ;
55779   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55780   std::string *arg2 = 0 ;
55781   Dali::Property::Map *arg3 = 0 ;
55782   Dali::BaseHandle result;
55783
55784   arg1 = (Dali::Toolkit::Builder *)jarg1;
55785   if (!jarg2) {
55786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55787     return 0;
55788   }
55789   std::string arg2_str(jarg2);
55790   arg2 = &arg2_str;
55791   arg3 = (Dali::Property::Map *)jarg3;
55792   if (!arg3) {
55793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55794     return 0;
55795   }
55796   {
55797     try {
55798       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
55799     } catch (std::out_of_range& e) {
55800       {
55801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55802       };
55803     } catch (std::exception& e) {
55804       {
55805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55806       };
55807     } catch (...) {
55808       {
55809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55810       };
55811     }
55812   }
55813   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55814
55815   //argout typemap for const std::string&
55816
55817   return jresult;
55818 }
55819
55820
55821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
55822   void * jresult ;
55823   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55824   std::string *arg2 = 0 ;
55825   Dali::BaseHandle result;
55826
55827   arg1 = (Dali::Toolkit::Builder *)jarg1;
55828   if (!jarg2) {
55829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55830     return 0;
55831   }
55832   std::string arg2_str(jarg2);
55833   arg2 = &arg2_str;
55834   {
55835     try {
55836       result = (arg1)->CreateFromJson((std::string const &)*arg2);
55837     } catch (std::out_of_range& e) {
55838       {
55839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55840       };
55841     } catch (std::exception& e) {
55842       {
55843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55844       };
55845     } catch (...) {
55846       {
55847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55848       };
55849     }
55850   }
55851   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55852
55853   //argout typemap for const std::string&
55854
55855   return jresult;
55856 }
55857
55858
55859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
55860   unsigned int jresult ;
55861   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55862   std::string *arg2 = 0 ;
55863   Dali::Handle *arg3 = 0 ;
55864   bool result;
55865
55866   arg1 = (Dali::Toolkit::Builder *)jarg1;
55867   if (!jarg2) {
55868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55869     return 0;
55870   }
55871   std::string arg2_str(jarg2);
55872   arg2 = &arg2_str;
55873   arg3 = (Dali::Handle *)jarg3;
55874   if (!arg3) {
55875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
55876     return 0;
55877   }
55878   {
55879     try {
55880       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
55881     } catch (std::out_of_range& e) {
55882       {
55883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55884       };
55885     } catch (std::exception& e) {
55886       {
55887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55888       };
55889     } catch (...) {
55890       {
55891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55892       };
55893     }
55894   }
55895   jresult = result;
55896
55897   //argout typemap for const std::string&
55898
55899   return jresult;
55900 }
55901
55902
55903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
55904   unsigned int jresult ;
55905   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55906   Dali::Handle *arg2 = 0 ;
55907   std::string *arg3 = 0 ;
55908   bool result;
55909
55910   arg1 = (Dali::Toolkit::Builder *)jarg1;
55911   arg2 = (Dali::Handle *)jarg2;
55912   if (!arg2) {
55913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
55914     return 0;
55915   }
55916   if (!jarg3) {
55917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55918     return 0;
55919   }
55920   std::string arg3_str(jarg3);
55921   arg3 = &arg3_str;
55922   {
55923     try {
55924       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
55925     } catch (std::out_of_range& e) {
55926       {
55927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55928       };
55929     } catch (std::exception& e) {
55930       {
55931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55932       };
55933     } catch (...) {
55934       {
55935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55936       };
55937     }
55938   }
55939   jresult = result;
55940
55941   //argout typemap for const std::string&
55942
55943   return jresult;
55944 }
55945
55946
55947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
55948   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55949   Dali::Actor arg2 ;
55950   Dali::Actor *argp2 ;
55951
55952   arg1 = (Dali::Toolkit::Builder *)jarg1;
55953   argp2 = (Dali::Actor *)jarg2;
55954   if (!argp2) {
55955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55956     return ;
55957   }
55958   arg2 = *argp2;
55959   {
55960     try {
55961       (arg1)->AddActors(arg2);
55962     } catch (std::out_of_range& e) {
55963       {
55964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55965       };
55966     } catch (std::exception& e) {
55967       {
55968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55969       };
55970     } catch (...) {
55971       {
55972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55973       };
55974     }
55975   }
55976 }
55977
55978
55979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
55980   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55981   std::string *arg2 = 0 ;
55982   Dali::Actor arg3 ;
55983   Dali::Actor *argp3 ;
55984
55985   arg1 = (Dali::Toolkit::Builder *)jarg1;
55986   if (!jarg2) {
55987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55988     return ;
55989   }
55990   std::string arg2_str(jarg2);
55991   arg2 = &arg2_str;
55992   argp3 = (Dali::Actor *)jarg3;
55993   if (!argp3) {
55994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55995     return ;
55996   }
55997   arg3 = *argp3;
55998   {
55999     try {
56000       (arg1)->AddActors((std::string const &)*arg2,arg3);
56001     } catch (std::out_of_range& e) {
56002       {
56003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56004       };
56005     } catch (std::exception& e) {
56006       {
56007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56008       };
56009     } catch (...) {
56010       {
56011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56012       };
56013     }
56014   }
56015
56016   //argout typemap for const std::string&
56017
56018 }
56019
56020
56021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
56022   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56023   std::string *arg2 = 0 ;
56024
56025   arg1 = (Dali::Toolkit::Builder *)jarg1;
56026   if (!jarg2) {
56027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56028     return ;
56029   }
56030   std::string arg2_str(jarg2);
56031   arg2 = &arg2_str;
56032   {
56033     try {
56034       (arg1)->CreateRenderTask((std::string const &)*arg2);
56035     } catch (std::out_of_range& e) {
56036       {
56037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56038       };
56039     } catch (std::exception& e) {
56040       {
56041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56042       };
56043     } catch (...) {
56044       {
56045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56046       };
56047     }
56048   }
56049
56050   //argout typemap for const std::string&
56051
56052 }
56053
56054
56055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
56056   void * jresult ;
56057   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56058   std::string *arg2 = 0 ;
56059   Dali::FrameBufferImage result;
56060
56061   arg1 = (Dali::Toolkit::Builder *)jarg1;
56062   if (!jarg2) {
56063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56064     return 0;
56065   }
56066   std::string arg2_str(jarg2);
56067   arg2 = &arg2_str;
56068   {
56069     try {
56070       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
56071     } catch (std::out_of_range& e) {
56072       {
56073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56074       };
56075     } catch (std::exception& e) {
56076       {
56077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56078       };
56079     } catch (...) {
56080       {
56081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56082       };
56083     }
56084   }
56085   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
56086
56087   //argout typemap for const std::string&
56088
56089   return jresult;
56090 }
56091
56092
56093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
56094   void * jresult ;
56095   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56096   std::string *arg2 = 0 ;
56097   Dali::Path result;
56098
56099   arg1 = (Dali::Toolkit::Builder *)jarg1;
56100   if (!jarg2) {
56101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56102     return 0;
56103   }
56104   std::string arg2_str(jarg2);
56105   arg2 = &arg2_str;
56106   {
56107     try {
56108       result = (arg1)->GetPath((std::string const &)*arg2);
56109     } catch (std::out_of_range& e) {
56110       {
56111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56112       };
56113     } catch (std::exception& e) {
56114       {
56115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56116       };
56117     } catch (...) {
56118       {
56119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56120       };
56121     }
56122   }
56123   jresult = new Dali::Path((const Dali::Path &)result);
56124
56125   //argout typemap for const std::string&
56126
56127   return jresult;
56128 }
56129
56130
56131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
56132   void * jresult ;
56133   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56134   std::string *arg2 = 0 ;
56135   Dali::PathConstrainer result;
56136
56137   arg1 = (Dali::Toolkit::Builder *)jarg1;
56138   if (!jarg2) {
56139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56140     return 0;
56141   }
56142   std::string arg2_str(jarg2);
56143   arg2 = &arg2_str;
56144   {
56145     try {
56146       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
56147     } catch (std::out_of_range& e) {
56148       {
56149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56150       };
56151     } catch (std::exception& e) {
56152       {
56153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56154       };
56155     } catch (...) {
56156       {
56157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56158       };
56159     }
56160   }
56161   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
56162
56163   //argout typemap for const std::string&
56164
56165   return jresult;
56166 }
56167
56168
56169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
56170   void * jresult ;
56171   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56172   std::string *arg2 = 0 ;
56173   Dali::LinearConstrainer result;
56174
56175   arg1 = (Dali::Toolkit::Builder *)jarg1;
56176   if (!jarg2) {
56177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56178     return 0;
56179   }
56180   std::string arg2_str(jarg2);
56181   arg2 = &arg2_str;
56182   {
56183     try {
56184       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56196       };
56197     }
56198   }
56199   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
56200
56201   //argout typemap for const std::string&
56202
56203   return jresult;
56204 }
56205
56206
56207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
56208   void * jresult ;
56209   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56210   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
56211
56212   arg1 = (Dali::Toolkit::Builder *)jarg1;
56213   {
56214     try {
56215       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
56216     } catch (std::out_of_range& e) {
56217       {
56218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56219       };
56220     } catch (std::exception& e) {
56221       {
56222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56223       };
56224     } catch (...) {
56225       {
56226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56227       };
56228     }
56229   }
56230   jresult = (void *)result;
56231   return jresult;
56232 }
56233
56234
56235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
56236   void * jresult ;
56237   Dali::Toolkit::TransitionData *result = 0 ;
56238
56239   {
56240     try {
56241       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
56242     } catch (std::out_of_range& e) {
56243       {
56244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (std::exception& e) {
56247       {
56248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56253       };
56254     }
56255   }
56256   jresult = (void *)result;
56257   return jresult;
56258 }
56259
56260
56261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
56262   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56263
56264   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56265   {
56266     try {
56267       delete arg1;
56268     } catch (std::out_of_range& e) {
56269       {
56270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56271       };
56272     } catch (std::exception& e) {
56273       {
56274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56275       };
56276     } catch (...) {
56277       {
56278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56279       };
56280     }
56281   }
56282 }
56283
56284
56285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
56286   void * jresult ;
56287   Dali::Property::Map *arg1 = 0 ;
56288   Dali::Toolkit::TransitionData result;
56289
56290   arg1 = (Dali::Property::Map *)jarg1;
56291   if (!arg1) {
56292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56293     return 0;
56294   }
56295   {
56296     try {
56297       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
56298     } catch (std::out_of_range& e) {
56299       {
56300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56301       };
56302     } catch (std::exception& e) {
56303       {
56304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56305       };
56306     } catch (...) {
56307       {
56308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56309       };
56310     }
56311   }
56312   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56313   return jresult;
56314 }
56315
56316
56317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
56318   void * jresult ;
56319   Dali::Property::Array *arg1 = 0 ;
56320   Dali::Toolkit::TransitionData result;
56321
56322   arg1 = (Dali::Property::Array *)jarg1;
56323   if (!arg1) {
56324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
56325     return 0;
56326   }
56327   {
56328     try {
56329       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
56330     } catch (std::out_of_range& e) {
56331       {
56332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56333       };
56334     } catch (std::exception& e) {
56335       {
56336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56337       };
56338     } catch (...) {
56339       {
56340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56341       };
56342     }
56343   }
56344   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56345   return jresult;
56346 }
56347
56348
56349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
56350   void * jresult ;
56351   Dali::BaseHandle arg1 ;
56352   Dali::BaseHandle *argp1 ;
56353   Dali::Toolkit::TransitionData result;
56354
56355   argp1 = (Dali::BaseHandle *)jarg1;
56356   if (!argp1) {
56357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
56358     return 0;
56359   }
56360   arg1 = *argp1;
56361   {
56362     try {
56363       result = Dali::Toolkit::TransitionData::DownCast(arg1);
56364     } catch (std::out_of_range& e) {
56365       {
56366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56367       };
56368     } catch (std::exception& e) {
56369       {
56370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56371       };
56372     } catch (...) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56375       };
56376     }
56377   }
56378   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56379   return jresult;
56380 }
56381
56382
56383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
56384   void * jresult ;
56385   Dali::Toolkit::TransitionData *arg1 = 0 ;
56386   Dali::Toolkit::TransitionData *result = 0 ;
56387
56388   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56389   if (!arg1) {
56390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
56391     return 0;
56392   }
56393   {
56394     try {
56395       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
56396     } catch (std::out_of_range& e) {
56397       {
56398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56399       };
56400     } catch (std::exception& e) {
56401       {
56402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56403       };
56404     } catch (...) {
56405       {
56406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56407       };
56408     }
56409   }
56410   jresult = (void *)result;
56411   return jresult;
56412 }
56413
56414
56415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
56416   void * jresult ;
56417   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56418   Dali::Toolkit::TransitionData *arg2 = 0 ;
56419   Dali::Toolkit::TransitionData *result = 0 ;
56420
56421   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56422   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
56423   if (!arg2) {
56424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
56425     return 0;
56426   }
56427   {
56428     try {
56429       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
56430     } catch (std::out_of_range& e) {
56431       {
56432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56433       };
56434     } catch (std::exception& e) {
56435       {
56436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56437       };
56438     } catch (...) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56441       };
56442     }
56443   }
56444   jresult = (void *)result;
56445   return jresult;
56446 }
56447
56448
56449 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
56450   unsigned long jresult ;
56451   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56452   size_t result;
56453
56454   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56455   {
56456     try {
56457       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
56458     } catch (std::out_of_range& e) {
56459       {
56460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (std::exception& e) {
56463       {
56464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56465       };
56466     } catch (...) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56469       };
56470     }
56471   }
56472   jresult = (unsigned long)result;
56473   return jresult;
56474 }
56475
56476
56477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
56478   void * jresult ;
56479   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56480   size_t arg2 ;
56481   Dali::Property::Map result;
56482
56483   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56484   arg2 = (size_t)jarg2;
56485   {
56486     try {
56487       result = (arg1)->GetAnimatorAt(arg2);
56488     } catch (std::out_of_range& e) {
56489       {
56490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56491       };
56492     } catch (std::exception& e) {
56493       {
56494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56495       };
56496     } catch (...) {
56497       {
56498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56499       };
56500     }
56501   }
56502   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
56503   return jresult;
56504 }
56505
56506
56507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
56508   void * jresult ;
56509   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
56510   Dali::Toolkit::TransitionData *result = 0 ;
56511
56512   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
56513   {
56514     try {
56515       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
56516     } catch (std::out_of_range& e) {
56517       {
56518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56519       };
56520     } catch (std::exception& e) {
56521       {
56522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (...) {
56525       {
56526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56527       };
56528     }
56529   }
56530   jresult = (void *)result;
56531   return jresult;
56532 }
56533
56534
56535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
56536   int jresult ;
56537   int result;
56538
56539   {
56540     try {
56541       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
56542     } catch (std::out_of_range& e) {
56543       {
56544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56545       };
56546     } catch (std::exception& e) {
56547       {
56548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56549       };
56550     } catch (...) {
56551       {
56552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56553       };
56554     }
56555   }
56556   jresult = (int)result;
56557   return jresult;
56558 }
56559
56560
56561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
56562   int jresult ;
56563   int result;
56564
56565   {
56566     try {
56567       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
56568     } catch (std::out_of_range& e) {
56569       {
56570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56571       };
56572     } catch (std::exception& e) {
56573       {
56574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56575       };
56576     } catch (...) {
56577       {
56578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56579       };
56580     }
56581   }
56582   jresult = (int)result;
56583   return jresult;
56584 }
56585
56586
56587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
56588   int jresult ;
56589   int result;
56590
56591   {
56592     try {
56593       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
56594     } catch (std::out_of_range& e) {
56595       {
56596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56597       };
56598     } catch (std::exception& e) {
56599       {
56600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56601       };
56602     } catch (...) {
56603       {
56604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56605       };
56606     }
56607   }
56608   jresult = (int)result;
56609   return jresult;
56610 }
56611
56612
56613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
56614   int jresult ;
56615   int result;
56616
56617   {
56618     try {
56619       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
56620     } catch (std::out_of_range& e) {
56621       {
56622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56623       };
56624     } catch (std::exception& e) {
56625       {
56626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56627       };
56628     } catch (...) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56631       };
56632     }
56633   }
56634   jresult = (int)result;
56635   return jresult;
56636 }
56637
56638
56639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
56640   int jresult ;
56641   int result;
56642
56643   {
56644     try {
56645       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
56646     } catch (std::out_of_range& e) {
56647       {
56648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56649       };
56650     } catch (std::exception& e) {
56651       {
56652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56653       };
56654     } catch (...) {
56655       {
56656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56657       };
56658     }
56659   }
56660   jresult = (int)result;
56661   return jresult;
56662 }
56663
56664
56665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
56666   int jresult ;
56667   int result;
56668
56669   {
56670     try {
56671       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
56672     } catch (std::out_of_range& e) {
56673       {
56674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56675       };
56676     } catch (std::exception& e) {
56677       {
56678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56679       };
56680     } catch (...) {
56681       {
56682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56683       };
56684     }
56685   }
56686   jresult = (int)result;
56687   return jresult;
56688 }
56689
56690
56691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
56692   int jresult ;
56693   int result;
56694
56695   {
56696     try {
56697       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
56698     } catch (std::out_of_range& e) {
56699       {
56700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56701       };
56702     } catch (std::exception& e) {
56703       {
56704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56705       };
56706     } catch (...) {
56707       {
56708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56709       };
56710     }
56711   }
56712   jresult = (int)result;
56713   return jresult;
56714 }
56715
56716
56717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
56718   int jresult ;
56719   int result;
56720
56721   {
56722     try {
56723       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
56724     } catch (std::out_of_range& e) {
56725       {
56726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56727       };
56728     } catch (std::exception& e) {
56729       {
56730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56731       };
56732     } catch (...) {
56733       {
56734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56735       };
56736     }
56737   }
56738   jresult = (int)result;
56739   return jresult;
56740 }
56741
56742
56743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
56744   int jresult ;
56745   int result;
56746
56747   {
56748     try {
56749       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
56750     } catch (std::out_of_range& e) {
56751       {
56752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (std::exception& e) {
56755       {
56756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56757       };
56758     } catch (...) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56761       };
56762     }
56763   }
56764   jresult = (int)result;
56765   return jresult;
56766 }
56767
56768
56769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
56770   int jresult ;
56771   int result;
56772
56773   {
56774     try {
56775       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
56776     } catch (std::out_of_range& e) {
56777       {
56778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56779       };
56780     } catch (std::exception& e) {
56781       {
56782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56783       };
56784     } catch (...) {
56785       {
56786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56787       };
56788     }
56789   }
56790   jresult = (int)result;
56791   return jresult;
56792 }
56793
56794
56795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
56796   int jresult ;
56797   int result;
56798
56799   {
56800     try {
56801       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
56802     } catch (std::out_of_range& e) {
56803       {
56804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56805       };
56806     } catch (std::exception& e) {
56807       {
56808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56809       };
56810     } catch (...) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56813       };
56814     }
56815   }
56816   jresult = (int)result;
56817   return jresult;
56818 }
56819
56820
56821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
56822   int jresult ;
56823   int result;
56824
56825   {
56826     try {
56827       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
56828     } catch (std::out_of_range& e) {
56829       {
56830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56831       };
56832     } catch (std::exception& e) {
56833       {
56834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56835       };
56836     } catch (...) {
56837       {
56838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56839       };
56840     }
56841   }
56842   jresult = (int)result;
56843   return jresult;
56844 }
56845
56846
56847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
56848   int jresult ;
56849   int result;
56850
56851   {
56852     try {
56853       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
56854     } catch (std::out_of_range& e) {
56855       {
56856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56857       };
56858     } catch (std::exception& e) {
56859       {
56860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56861       };
56862     } catch (...) {
56863       {
56864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56865       };
56866     }
56867   }
56868   jresult = (int)result;
56869   return jresult;
56870 }
56871
56872
56873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
56874   int jresult ;
56875   int result;
56876
56877   {
56878     try {
56879       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
56880     } catch (std::out_of_range& e) {
56881       {
56882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56883       };
56884     } catch (std::exception& e) {
56885       {
56886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56887       };
56888     } catch (...) {
56889       {
56890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56891       };
56892     }
56893   }
56894   jresult = (int)result;
56895   return jresult;
56896 }
56897
56898
56899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
56900   void * jresult ;
56901   Dali::Toolkit::Control result;
56902
56903   {
56904     try {
56905       result = Dali::Toolkit::Internal::Control::New();
56906     } catch (std::out_of_range& e) {
56907       {
56908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56909       };
56910     } catch (std::exception& e) {
56911       {
56912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56913       };
56914     } catch (...) {
56915       {
56916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56917       };
56918     }
56919   }
56920   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
56921   return jresult;
56922 }
56923
56924
56925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
56926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56927   std::string *arg2 = 0 ;
56928
56929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56930   if (!jarg2) {
56931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56932     return ;
56933   }
56934   std::string arg2_str(jarg2);
56935   arg2 = &arg2_str;
56936   {
56937     try {
56938       (arg1)->SetStyleName((std::string const &)*arg2);
56939     } catch (std::out_of_range& e) {
56940       {
56941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56942       };
56943     } catch (std::exception& e) {
56944       {
56945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56946       };
56947     } catch (...) {
56948       {
56949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56950       };
56951     }
56952   }
56953
56954   //argout typemap for const std::string&
56955
56956 }
56957
56958
56959 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
56960   char * jresult ;
56961   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56962   std::string *result = 0 ;
56963
56964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56965   {
56966     try {
56967       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
56968     } catch (std::out_of_range& e) {
56969       {
56970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56971       };
56972     } catch (std::exception& e) {
56973       {
56974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56975       };
56976     } catch (...) {
56977       {
56978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56979       };
56980     }
56981   }
56982   jresult = SWIG_csharp_string_callback(result->c_str());
56983   return jresult;
56984 }
56985
56986
56987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
56988   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56989   Dali::Vector4 *arg2 = 0 ;
56990
56991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56992   arg2 = (Dali::Vector4 *)jarg2;
56993   if (!arg2) {
56994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
56995     return ;
56996   }
56997   {
56998     try {
56999       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
57000     } catch (std::out_of_range& e) {
57001       {
57002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57003       };
57004     } catch (std::exception& e) {
57005       {
57006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57007       };
57008     } catch (...) {
57009       {
57010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57011       };
57012     }
57013   }
57014 }
57015
57016
57017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
57018   void * jresult ;
57019   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57020   Dali::Vector4 result;
57021
57022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57023   {
57024     try {
57025       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
57026     } catch (std::out_of_range& e) {
57027       {
57028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57029       };
57030     } catch (std::exception& e) {
57031       {
57032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57033       };
57034     } catch (...) {
57035       {
57036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57037       };
57038     }
57039   }
57040   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
57041   return jresult;
57042 }
57043
57044
57045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
57046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57047   Dali::Image arg2 ;
57048   Dali::Image *argp2 ;
57049
57050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57051   argp2 = (Dali::Image *)jarg2;
57052   if (!argp2) {
57053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
57054     return ;
57055   }
57056   arg2 = *argp2;
57057   {
57058     try {
57059       (arg1)->SetBackgroundImage(arg2);
57060     } catch (std::out_of_range& e) {
57061       {
57062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57063       };
57064     } catch (std::exception& e) {
57065       {
57066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57067       };
57068     } catch (...) {
57069       {
57070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57071       };
57072     }
57073   }
57074 }
57075
57076
57077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
57078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57079   Dali::Property::Map *arg2 = 0 ;
57080
57081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57082   arg2 = (Dali::Property::Map *)jarg2;
57083   if (!arg2) {
57084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57085     return ;
57086   }
57087   {
57088     try {
57089       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
57090     } catch (std::out_of_range& e) {
57091       {
57092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57093       };
57094     } catch (std::exception& e) {
57095       {
57096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57097       };
57098     } catch (...) {
57099       {
57100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57101       };
57102     }
57103   }
57104 }
57105
57106
57107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
57108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57109
57110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57111   {
57112     try {
57113       (arg1)->ClearBackground();
57114     } catch (std::out_of_range& e) {
57115       {
57116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57117       };
57118     } catch (std::exception& e) {
57119       {
57120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57121       };
57122     } catch (...) {
57123       {
57124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57125       };
57126     }
57127   }
57128 }
57129
57130
57131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
57132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57133   Dali::Gesture::Type arg2 ;
57134
57135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57136   arg2 = (Dali::Gesture::Type)jarg2;
57137   {
57138     try {
57139       (arg1)->EnableGestureDetection(arg2);
57140     } catch (std::out_of_range& e) {
57141       {
57142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57143       };
57144     } catch (std::exception& e) {
57145       {
57146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57147       };
57148     } catch (...) {
57149       {
57150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57151       };
57152     }
57153   }
57154 }
57155
57156
57157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
57158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57159   Dali::Gesture::Type arg2 ;
57160
57161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57162   arg2 = (Dali::Gesture::Type)jarg2;
57163   {
57164     try {
57165       (arg1)->DisableGestureDetection(arg2);
57166     } catch (std::out_of_range& e) {
57167       {
57168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57169       };
57170     } catch (std::exception& e) {
57171       {
57172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57173       };
57174     } catch (...) {
57175       {
57176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57177       };
57178     }
57179   }
57180 }
57181
57182
57183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
57184   void * jresult ;
57185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57186   Dali::PinchGestureDetector result;
57187
57188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57189   {
57190     try {
57191       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
57192     } catch (std::out_of_range& e) {
57193       {
57194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57195       };
57196     } catch (std::exception& e) {
57197       {
57198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57199       };
57200     } catch (...) {
57201       {
57202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57203       };
57204     }
57205   }
57206   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
57207   return jresult;
57208 }
57209
57210
57211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
57212   void * jresult ;
57213   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57214   Dali::PanGestureDetector result;
57215
57216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57217   {
57218     try {
57219       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
57220     } catch (std::out_of_range& e) {
57221       {
57222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57223       };
57224     } catch (std::exception& e) {
57225       {
57226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57227       };
57228     } catch (...) {
57229       {
57230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57231       };
57232     }
57233   }
57234   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
57235   return jresult;
57236 }
57237
57238
57239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
57240   void * jresult ;
57241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57242   Dali::TapGestureDetector result;
57243
57244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57245   {
57246     try {
57247       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
57248     } catch (std::out_of_range& e) {
57249       {
57250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57251       };
57252     } catch (std::exception& e) {
57253       {
57254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57255       };
57256     } catch (...) {
57257       {
57258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57259       };
57260     }
57261   }
57262   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
57263   return jresult;
57264 }
57265
57266
57267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
57268   void * jresult ;
57269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57270   Dali::LongPressGestureDetector result;
57271
57272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57273   {
57274     try {
57275       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
57276     } catch (std::out_of_range& e) {
57277       {
57278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57279       };
57280     } catch (std::exception& e) {
57281       {
57282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57283       };
57284     } catch (...) {
57285       {
57286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57287       };
57288     }
57289   }
57290   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
57291   return jresult;
57292 }
57293
57294
57295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
57296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57297   bool arg2 ;
57298
57299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57300   arg2 = jarg2 ? true : false;
57301   {
57302     try {
57303       (arg1)->SetKeyboardNavigationSupport(arg2);
57304     } catch (std::out_of_range& e) {
57305       {
57306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57307       };
57308     } catch (std::exception& e) {
57309       {
57310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57311       };
57312     } catch (...) {
57313       {
57314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57315       };
57316     }
57317   }
57318 }
57319
57320
57321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
57322   unsigned int jresult ;
57323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57324   bool result;
57325
57326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57327   {
57328     try {
57329       result = (bool)(arg1)->IsKeyboardNavigationSupported();
57330     } catch (std::out_of_range& e) {
57331       {
57332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57333       };
57334     } catch (std::exception& e) {
57335       {
57336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57337       };
57338     } catch (...) {
57339       {
57340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57341       };
57342     }
57343   }
57344   jresult = result;
57345   return jresult;
57346 }
57347
57348
57349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
57350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57351
57352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57353   {
57354     try {
57355       (arg1)->SetKeyInputFocus();
57356     } catch (std::out_of_range& e) {
57357       {
57358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57359       };
57360     } catch (std::exception& e) {
57361       {
57362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57363       };
57364     } catch (...) {
57365       {
57366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57367       };
57368     }
57369   }
57370 }
57371
57372
57373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
57374   unsigned int jresult ;
57375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57376   bool result;
57377
57378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57379   {
57380     try {
57381       result = (bool)(arg1)->HasKeyInputFocus();
57382     } catch (std::out_of_range& e) {
57383       {
57384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57385       };
57386     } catch (std::exception& e) {
57387       {
57388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57389       };
57390     } catch (...) {
57391       {
57392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57393       };
57394     }
57395   }
57396   jresult = result;
57397   return jresult;
57398 }
57399
57400
57401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
57402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57403
57404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57405   {
57406     try {
57407       (arg1)->ClearKeyInputFocus();
57408     } catch (std::out_of_range& e) {
57409       {
57410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57411       };
57412     } catch (std::exception& e) {
57413       {
57414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57415       };
57416     } catch (...) {
57417       {
57418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57419       };
57420     }
57421   }
57422 }
57423
57424
57425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
57426   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57427   bool arg2 ;
57428
57429   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57430   arg2 = jarg2 ? true : false;
57431   {
57432     try {
57433       (arg1)->SetAsKeyboardFocusGroup(arg2);
57434     } catch (std::out_of_range& e) {
57435       {
57436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57437       };
57438     } catch (std::exception& e) {
57439       {
57440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57441       };
57442     } catch (...) {
57443       {
57444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57445       };
57446     }
57447   }
57448 }
57449
57450
57451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
57452   unsigned int jresult ;
57453   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57454   bool result;
57455
57456   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57457   {
57458     try {
57459       result = (bool)(arg1)->IsKeyboardFocusGroup();
57460     } catch (std::out_of_range& e) {
57461       {
57462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57463       };
57464     } catch (std::exception& e) {
57465       {
57466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57467       };
57468     } catch (...) {
57469       {
57470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57471       };
57472     }
57473   }
57474   jresult = result;
57475   return jresult;
57476 }
57477
57478
57479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
57480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57481
57482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57483   {
57484     try {
57485       (arg1)->AccessibilityActivate();
57486     } catch (std::out_of_range& e) {
57487       {
57488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57489       };
57490     } catch (std::exception& e) {
57491       {
57492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57493       };
57494     } catch (...) {
57495       {
57496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57497       };
57498     }
57499   }
57500 }
57501
57502
57503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
57504   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57505
57506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57507   {
57508     try {
57509       (arg1)->KeyboardEnter();
57510     } catch (std::out_of_range& e) {
57511       {
57512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57513       };
57514     } catch (std::exception& e) {
57515       {
57516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57517       };
57518     } catch (...) {
57519       {
57520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57521       };
57522     }
57523   }
57524 }
57525
57526
57527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
57528   void * jresult ;
57529   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57530   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
57531
57532   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57533   {
57534     try {
57535       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
57536     } catch (std::out_of_range& e) {
57537       {
57538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57539       };
57540     } catch (std::exception& e) {
57541       {
57542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57543       };
57544     } catch (...) {
57545       {
57546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57547       };
57548     }
57549   }
57550   jresult = (void *)result;
57551   return jresult;
57552 }
57553
57554
57555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
57556   void * jresult ;
57557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57558   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
57559
57560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57561   {
57562     try {
57563       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
57564     } catch (std::out_of_range& e) {
57565       {
57566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57567       };
57568     } catch (std::exception& e) {
57569       {
57570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57571       };
57572     } catch (...) {
57573       {
57574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57575       };
57576     }
57577   }
57578   jresult = (void *)result;
57579   return jresult;
57580 }
57581
57582
57583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
57584   void * jresult ;
57585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57586   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
57587
57588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57589   {
57590     try {
57591       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
57592     } catch (std::out_of_range& e) {
57593       {
57594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57595       };
57596     } catch (std::exception& e) {
57597       {
57598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57599       };
57600     } catch (...) {
57601       {
57602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57603       };
57604     }
57605   }
57606   jresult = (void *)result;
57607   return jresult;
57608 }
57609
57610
57611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
57612   unsigned int jresult ;
57613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57614   Dali::KeyEvent *arg2 = 0 ;
57615   bool result;
57616
57617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57618   arg2 = (Dali::KeyEvent *)jarg2;
57619   if (!arg2) {
57620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
57621     return 0;
57622   }
57623   {
57624     try {
57625       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
57626     } catch (std::out_of_range& e) {
57627       {
57628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57629       };
57630     } catch (std::exception& e) {
57631       {
57632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57633       };
57634     } catch (...) {
57635       {
57636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57637       };
57638     }
57639   }
57640   jresult = result;
57641   return jresult;
57642 }
57643
57644
57645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
57646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57647   int arg2 ;
57648   SwigDirector_ViewImpl *darg = 0;
57649
57650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57651   arg2 = (int)jarg2;
57652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57653   {
57654     try {
57655       (darg)->OnStageConnection(arg2);
57656     } catch (std::out_of_range& e) {
57657       {
57658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57659       };
57660     } catch (std::exception& e) {
57661       {
57662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57663       };
57664     } catch (...) {
57665       {
57666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57667       };
57668     }
57669   }
57670 }
57671
57672
57673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
57674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57675   int arg2 ;
57676   SwigDirector_ViewImpl *darg = 0;
57677
57678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57679   arg2 = (int)jarg2;
57680   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57681   {
57682     try {
57683       (darg)->OnStageConnectionSwigPublic(arg2);
57684     } catch (std::out_of_range& e) {
57685       {
57686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57687       };
57688     } catch (std::exception& e) {
57689       {
57690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57691       };
57692     } catch (...) {
57693       {
57694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57695       };
57696     }
57697   }
57698 }
57699
57700
57701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
57702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57703   SwigDirector_ViewImpl *darg = 0;
57704
57705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57706   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57707   {
57708     try {
57709       (darg)->OnStageDisconnection();
57710     } catch (std::out_of_range& e) {
57711       {
57712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57713       };
57714     } catch (std::exception& e) {
57715       {
57716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57717       };
57718     } catch (...) {
57719       {
57720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57721       };
57722     }
57723   }
57724 }
57725
57726
57727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
57728   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57729   SwigDirector_ViewImpl *darg = 0;
57730
57731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57732   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57733   {
57734     try {
57735       (darg)->OnStageDisconnectionSwigPublic();
57736     } catch (std::out_of_range& e) {
57737       {
57738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57739       };
57740     } catch (std::exception& e) {
57741       {
57742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57743       };
57744     } catch (...) {
57745       {
57746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57747       };
57748     }
57749   }
57750 }
57751
57752
57753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
57754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57755   Dali::Actor *arg2 = 0 ;
57756   SwigDirector_ViewImpl *darg = 0;
57757
57758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57759   arg2 = (Dali::Actor *)jarg2;
57760   if (!arg2) {
57761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57762     return ;
57763   }
57764   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57765   {
57766     try {
57767       (darg)->OnChildAdd(*arg2);
57768     } catch (std::out_of_range& e) {
57769       {
57770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57771       };
57772     } catch (std::exception& e) {
57773       {
57774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57775       };
57776     } catch (...) {
57777       {
57778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57779       };
57780     }
57781   }
57782 }
57783
57784
57785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57787   Dali::Actor *arg2 = 0 ;
57788   SwigDirector_ViewImpl *darg = 0;
57789
57790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57791   arg2 = (Dali::Actor *)jarg2;
57792   if (!arg2) {
57793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57794     return ;
57795   }
57796   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57797   {
57798     try {
57799       (darg)->OnChildAddSwigPublic(*arg2);
57800     } catch (std::out_of_range& e) {
57801       {
57802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57803       };
57804     } catch (std::exception& e) {
57805       {
57806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57807       };
57808     } catch (...) {
57809       {
57810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57811       };
57812     }
57813   }
57814 }
57815
57816
57817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
57818   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57819   Dali::Actor *arg2 = 0 ;
57820   SwigDirector_ViewImpl *darg = 0;
57821
57822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57823   arg2 = (Dali::Actor *)jarg2;
57824   if (!arg2) {
57825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57826     return ;
57827   }
57828   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57829   {
57830     try {
57831       (darg)->OnChildRemove(*arg2);
57832     } catch (std::out_of_range& e) {
57833       {
57834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57835       };
57836     } catch (std::exception& e) {
57837       {
57838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57839       };
57840     } catch (...) {
57841       {
57842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57843       };
57844     }
57845   }
57846 }
57847
57848
57849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57851   Dali::Actor *arg2 = 0 ;
57852   SwigDirector_ViewImpl *darg = 0;
57853
57854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57855   arg2 = (Dali::Actor *)jarg2;
57856   if (!arg2) {
57857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57858     return ;
57859   }
57860   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57861   {
57862     try {
57863       (darg)->OnChildRemoveSwigPublic(*arg2);
57864     } catch (std::out_of_range& e) {
57865       {
57866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57867       };
57868     } catch (std::exception& e) {
57869       {
57870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57871       };
57872     } catch (...) {
57873       {
57874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57875       };
57876     }
57877   }
57878 }
57879
57880
57881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
57882   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57883   Dali::Property::Index arg2 ;
57884   Dali::Property::Value arg3 ;
57885   Dali::Property::Value *argp3 ;
57886   SwigDirector_ViewImpl *darg = 0;
57887
57888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57889   arg2 = (Dali::Property::Index)jarg2;
57890   argp3 = (Dali::Property::Value *)jarg3;
57891   if (!argp3) {
57892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
57893     return ;
57894   }
57895   arg3 = *argp3;
57896   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57897   {
57898     try {
57899       (darg)->OnPropertySet(arg2,arg3);
57900     } catch (std::out_of_range& e) {
57901       {
57902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57903       };
57904     } catch (std::exception& e) {
57905       {
57906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57907       };
57908     } catch (...) {
57909       {
57910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57911       };
57912     }
57913   }
57914 }
57915
57916
57917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
57918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57919   Dali::Property::Index arg2 ;
57920   Dali::Property::Value arg3 ;
57921   Dali::Property::Value *argp3 ;
57922   SwigDirector_ViewImpl *darg = 0;
57923
57924   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57925   arg2 = (Dali::Property::Index)jarg2;
57926   argp3 = (Dali::Property::Value *)jarg3;
57927   if (!argp3) {
57928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
57929     return ;
57930   }
57931   arg3 = *argp3;
57932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57933   {
57934     try {
57935       (darg)->OnPropertySetSwigPublic(arg2,arg3);
57936     } catch (std::out_of_range& e) {
57937       {
57938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57939       };
57940     } catch (std::exception& e) {
57941       {
57942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57943       };
57944     } catch (...) {
57945       {
57946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57947       };
57948     }
57949   }
57950 }
57951
57952
57953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
57954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57955   Dali::Vector3 *arg2 = 0 ;
57956   SwigDirector_ViewImpl *darg = 0;
57957
57958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57959   arg2 = (Dali::Vector3 *)jarg2;
57960   if (!arg2) {
57961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
57962     return ;
57963   }
57964   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57965   {
57966     try {
57967       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
57968     } catch (std::out_of_range& e) {
57969       {
57970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57971       };
57972     } catch (std::exception& e) {
57973       {
57974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57975       };
57976     } catch (...) {
57977       {
57978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57979       };
57980     }
57981   }
57982 }
57983
57984
57985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57987   Dali::Vector3 *arg2 = 0 ;
57988   SwigDirector_ViewImpl *darg = 0;
57989
57990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57991   arg2 = (Dali::Vector3 *)jarg2;
57992   if (!arg2) {
57993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
57994     return ;
57995   }
57996   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57997   {
57998     try {
57999       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
58000     } catch (std::out_of_range& e) {
58001       {
58002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58003       };
58004     } catch (std::exception& e) {
58005       {
58006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58007       };
58008     } catch (...) {
58009       {
58010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58011       };
58012     }
58013   }
58014 }
58015
58016
58017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
58018   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58019   Dali::Animation *arg2 = 0 ;
58020   Dali::Vector3 *arg3 = 0 ;
58021   SwigDirector_ViewImpl *darg = 0;
58022
58023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58024   arg2 = (Dali::Animation *)jarg2;
58025   if (!arg2) {
58026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
58027     return ;
58028   }
58029   arg3 = (Dali::Vector3 *)jarg3;
58030   if (!arg3) {
58031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58032     return ;
58033   }
58034   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58035   {
58036     try {
58037       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
58038     } catch (std::out_of_range& e) {
58039       {
58040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58041       };
58042     } catch (std::exception& e) {
58043       {
58044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58045       };
58046     } catch (...) {
58047       {
58048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58049       };
58050     }
58051   }
58052 }
58053
58054
58055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58057   Dali::Animation *arg2 = 0 ;
58058   Dali::Vector3 *arg3 = 0 ;
58059   SwigDirector_ViewImpl *darg = 0;
58060
58061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58062   arg2 = (Dali::Animation *)jarg2;
58063   if (!arg2) {
58064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
58065     return ;
58066   }
58067   arg3 = (Dali::Vector3 *)jarg3;
58068   if (!arg3) {
58069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58070     return ;
58071   }
58072   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58073   {
58074     try {
58075       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
58076     } catch (std::out_of_range& e) {
58077       {
58078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58079       };
58080     } catch (std::exception& e) {
58081       {
58082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58083       };
58084     } catch (...) {
58085       {
58086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58087       };
58088     }
58089   }
58090 }
58091
58092
58093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
58094   unsigned int jresult ;
58095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58096   Dali::TouchEvent *arg2 = 0 ;
58097   SwigDirector_ViewImpl *darg = 0;
58098   bool result;
58099
58100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58101   arg2 = (Dali::TouchEvent *)jarg2;
58102   if (!arg2) {
58103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
58104     return 0;
58105   }
58106   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58107   {
58108     try {
58109       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
58110     } catch (std::out_of_range& e) {
58111       {
58112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58113       };
58114     } catch (std::exception& e) {
58115       {
58116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58117       };
58118     } catch (...) {
58119       {
58120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58121       };
58122     }
58123   }
58124   jresult = result;
58125   return jresult;
58126 }
58127
58128
58129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58130   unsigned int jresult ;
58131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58132   Dali::TouchEvent *arg2 = 0 ;
58133   SwigDirector_ViewImpl *darg = 0;
58134   bool result;
58135
58136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58137   arg2 = (Dali::TouchEvent *)jarg2;
58138   if (!arg2) {
58139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
58140     return 0;
58141   }
58142   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58143   {
58144     try {
58145       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
58146     } catch (std::out_of_range& e) {
58147       {
58148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58149       };
58150     } catch (std::exception& e) {
58151       {
58152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58153       };
58154     } catch (...) {
58155       {
58156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58157       };
58158     }
58159   }
58160   jresult = result;
58161   return jresult;
58162 }
58163
58164
58165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
58166   unsigned int jresult ;
58167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58168   Dali::HoverEvent *arg2 = 0 ;
58169   SwigDirector_ViewImpl *darg = 0;
58170   bool result;
58171
58172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58173   arg2 = (Dali::HoverEvent *)jarg2;
58174   if (!arg2) {
58175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
58176     return 0;
58177   }
58178   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58179   {
58180     try {
58181       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
58182     } catch (std::out_of_range& e) {
58183       {
58184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58185       };
58186     } catch (std::exception& e) {
58187       {
58188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58189       };
58190     } catch (...) {
58191       {
58192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58193       };
58194     }
58195   }
58196   jresult = result;
58197   return jresult;
58198 }
58199
58200
58201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58202   unsigned int jresult ;
58203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58204   Dali::HoverEvent *arg2 = 0 ;
58205   SwigDirector_ViewImpl *darg = 0;
58206   bool result;
58207
58208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58209   arg2 = (Dali::HoverEvent *)jarg2;
58210   if (!arg2) {
58211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
58212     return 0;
58213   }
58214   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58215   {
58216     try {
58217       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
58218     } catch (std::out_of_range& e) {
58219       {
58220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58221       };
58222     } catch (std::exception& e) {
58223       {
58224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (...) {
58227       {
58228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58229       };
58230     }
58231   }
58232   jresult = result;
58233   return jresult;
58234 }
58235
58236
58237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
58238   unsigned int jresult ;
58239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58240   Dali::KeyEvent *arg2 = 0 ;
58241   SwigDirector_ViewImpl *darg = 0;
58242   bool result;
58243
58244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58245   arg2 = (Dali::KeyEvent *)jarg2;
58246   if (!arg2) {
58247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
58248     return 0;
58249   }
58250   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58251   {
58252     try {
58253       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
58254     } catch (std::out_of_range& e) {
58255       {
58256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58257       };
58258     } catch (std::exception& e) {
58259       {
58260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58261       };
58262     } catch (...) {
58263       {
58264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58265       };
58266     }
58267   }
58268   jresult = result;
58269   return jresult;
58270 }
58271
58272
58273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58274   unsigned int jresult ;
58275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58276   Dali::KeyEvent *arg2 = 0 ;
58277   SwigDirector_ViewImpl *darg = 0;
58278   bool result;
58279
58280   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58281   arg2 = (Dali::KeyEvent *)jarg2;
58282   if (!arg2) {
58283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
58284     return 0;
58285   }
58286   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58287   {
58288     try {
58289       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
58290     } catch (std::out_of_range& e) {
58291       {
58292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58293       };
58294     } catch (std::exception& e) {
58295       {
58296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58297       };
58298     } catch (...) {
58299       {
58300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58301       };
58302     }
58303   }
58304   jresult = result;
58305   return jresult;
58306 }
58307
58308
58309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
58310   unsigned int jresult ;
58311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58312   Dali::WheelEvent *arg2 = 0 ;
58313   SwigDirector_ViewImpl *darg = 0;
58314   bool result;
58315
58316   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58317   arg2 = (Dali::WheelEvent *)jarg2;
58318   if (!arg2) {
58319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
58320     return 0;
58321   }
58322   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58323   {
58324     try {
58325       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
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 = result;
58341   return jresult;
58342 }
58343
58344
58345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58346   unsigned int jresult ;
58347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58348   Dali::WheelEvent *arg2 = 0 ;
58349   SwigDirector_ViewImpl *darg = 0;
58350   bool result;
58351
58352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58353   arg2 = (Dali::WheelEvent *)jarg2;
58354   if (!arg2) {
58355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
58356     return 0;
58357   }
58358   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58359   {
58360     try {
58361       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
58362     } catch (std::out_of_range& e) {
58363       {
58364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58365       };
58366     } catch (std::exception& e) {
58367       {
58368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58369       };
58370     } catch (...) {
58371       {
58372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58373       };
58374     }
58375   }
58376   jresult = result;
58377   return jresult;
58378 }
58379
58380
58381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
58382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58383   Dali::Vector2 *arg2 = 0 ;
58384   Dali::RelayoutContainer *arg3 = 0 ;
58385   SwigDirector_ViewImpl *darg = 0;
58386
58387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58388   arg2 = (Dali::Vector2 *)jarg2;
58389   if (!arg2) {
58390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
58391     return ;
58392   }
58393   arg3 = (Dali::RelayoutContainer *)jarg3;
58394   if (!arg3) {
58395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
58396     return ;
58397   }
58398   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58399   {
58400     try {
58401       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
58402     } catch (std::out_of_range& e) {
58403       {
58404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58405       };
58406     } catch (std::exception& e) {
58407       {
58408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58409       };
58410     } catch (...) {
58411       {
58412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58413       };
58414     }
58415   }
58416 }
58417
58418
58419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58421   Dali::Vector2 *arg2 = 0 ;
58422   Dali::RelayoutContainer *arg3 = 0 ;
58423   SwigDirector_ViewImpl *darg = 0;
58424
58425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58426   arg2 = (Dali::Vector2 *)jarg2;
58427   if (!arg2) {
58428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
58429     return ;
58430   }
58431   arg3 = (Dali::RelayoutContainer *)jarg3;
58432   if (!arg3) {
58433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
58434     return ;
58435   }
58436   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58437   {
58438     try {
58439       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
58440     } catch (std::out_of_range& e) {
58441       {
58442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58443       };
58444     } catch (std::exception& e) {
58445       {
58446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58447       };
58448     } catch (...) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58451       };
58452     }
58453   }
58454 }
58455
58456
58457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
58458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58459   Dali::ResizePolicy::Type arg2 ;
58460   Dali::Dimension::Type arg3 ;
58461   SwigDirector_ViewImpl *darg = 0;
58462
58463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58464   arg2 = (Dali::ResizePolicy::Type)jarg2;
58465   arg3 = (Dali::Dimension::Type)jarg3;
58466   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58467   {
58468     try {
58469       (darg)->OnSetResizePolicy(arg2,arg3);
58470     } catch (std::out_of_range& e) {
58471       {
58472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58473       };
58474     } catch (std::exception& e) {
58475       {
58476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58477       };
58478     } catch (...) {
58479       {
58480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58481       };
58482     }
58483   }
58484 }
58485
58486
58487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
58488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58489   Dali::ResizePolicy::Type arg2 ;
58490   Dali::Dimension::Type arg3 ;
58491   SwigDirector_ViewImpl *darg = 0;
58492
58493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58494   arg2 = (Dali::ResizePolicy::Type)jarg2;
58495   arg3 = (Dali::Dimension::Type)jarg3;
58496   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58497   {
58498     try {
58499       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
58500     } catch (std::out_of_range& e) {
58501       {
58502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58503       };
58504     } catch (std::exception& e) {
58505       {
58506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58507       };
58508     } catch (...) {
58509       {
58510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58511       };
58512     }
58513   }
58514 }
58515
58516
58517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
58518   void * jresult ;
58519   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58520   SwigDirector_ViewImpl *darg = 0;
58521   Dali::Vector3 result;
58522
58523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58524   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58525   {
58526     try {
58527       result = (darg)->GetNaturalSize();
58528     } catch (std::out_of_range& e) {
58529       {
58530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58531       };
58532     } catch (std::exception& e) {
58533       {
58534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58535       };
58536     } catch (...) {
58537       {
58538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58539       };
58540     }
58541   }
58542   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
58543   return jresult;
58544 }
58545
58546
58547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
58548   void * jresult ;
58549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58550   SwigDirector_ViewImpl *darg = 0;
58551   Dali::Vector3 result;
58552
58553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58554   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58555   {
58556     try {
58557       result = (darg)->GetNaturalSizeSwigPublic();
58558     } catch (std::out_of_range& e) {
58559       {
58560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58561       };
58562     } catch (std::exception& e) {
58563       {
58564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58565       };
58566     } catch (...) {
58567       {
58568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58569       };
58570     }
58571   }
58572   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
58573   return jresult;
58574 }
58575
58576
58577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
58578   float jresult ;
58579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58580   Dali::Actor *arg2 = 0 ;
58581   Dali::Dimension::Type arg3 ;
58582   SwigDirector_ViewImpl *darg = 0;
58583   float result;
58584
58585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58586   arg2 = (Dali::Actor *)jarg2;
58587   if (!arg2) {
58588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
58589     return 0;
58590   }
58591   arg3 = (Dali::Dimension::Type)jarg3;
58592   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58593   {
58594     try {
58595       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
58596     } catch (std::out_of_range& e) {
58597       {
58598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58599       };
58600     } catch (std::exception& e) {
58601       {
58602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58607       };
58608     }
58609   }
58610   jresult = result;
58611   return jresult;
58612 }
58613
58614
58615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
58616   float jresult ;
58617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58618   Dali::Actor *arg2 = 0 ;
58619   Dali::Dimension::Type arg3 ;
58620   SwigDirector_ViewImpl *darg = 0;
58621   float result;
58622
58623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58624   arg2 = (Dali::Actor *)jarg2;
58625   if (!arg2) {
58626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
58627     return 0;
58628   }
58629   arg3 = (Dali::Dimension::Type)jarg3;
58630   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58631   {
58632     try {
58633       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
58634     } catch (std::out_of_range& e) {
58635       {
58636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58637       };
58638     } catch (std::exception& e) {
58639       {
58640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58641       };
58642     } catch (...) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58645       };
58646     }
58647   }
58648   jresult = result;
58649   return jresult;
58650 }
58651
58652
58653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
58654   float jresult ;
58655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58656   float arg2 ;
58657   SwigDirector_ViewImpl *darg = 0;
58658   float result;
58659
58660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58661   arg2 = (float)jarg2;
58662   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58663   {
58664     try {
58665       result = (float)(darg)->GetHeightForWidth(arg2);
58666     } catch (std::out_of_range& e) {
58667       {
58668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58669       };
58670     } catch (std::exception& e) {
58671       {
58672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58673       };
58674     } catch (...) {
58675       {
58676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58677       };
58678     }
58679   }
58680   jresult = result;
58681   return jresult;
58682 }
58683
58684
58685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
58686   float jresult ;
58687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58688   float arg2 ;
58689   SwigDirector_ViewImpl *darg = 0;
58690   float result;
58691
58692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58693   arg2 = (float)jarg2;
58694   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58695   {
58696     try {
58697       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
58698     } catch (std::out_of_range& e) {
58699       {
58700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58701       };
58702     } catch (std::exception& e) {
58703       {
58704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58705       };
58706     } catch (...) {
58707       {
58708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58709       };
58710     }
58711   }
58712   jresult = result;
58713   return jresult;
58714 }
58715
58716
58717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
58718   float jresult ;
58719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58720   float arg2 ;
58721   SwigDirector_ViewImpl *darg = 0;
58722   float result;
58723
58724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58725   arg2 = (float)jarg2;
58726   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58727   {
58728     try {
58729       result = (float)(darg)->GetWidthForHeight(arg2);
58730     } catch (std::out_of_range& e) {
58731       {
58732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58733       };
58734     } catch (std::exception& e) {
58735       {
58736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58737       };
58738     } catch (...) {
58739       {
58740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58741       };
58742     }
58743   }
58744   jresult = result;
58745   return jresult;
58746 }
58747
58748
58749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
58750   float jresult ;
58751   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58752   float arg2 ;
58753   SwigDirector_ViewImpl *darg = 0;
58754   float result;
58755
58756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58757   arg2 = (float)jarg2;
58758   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58759   {
58760     try {
58761       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
58762     } catch (std::out_of_range& e) {
58763       {
58764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58765       };
58766     } catch (std::exception& e) {
58767       {
58768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58769       };
58770     } catch (...) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58773       };
58774     }
58775   }
58776   jresult = result;
58777   return jresult;
58778 }
58779
58780
58781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
58782   unsigned int jresult ;
58783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58784   Dali::Dimension::Type arg2 ;
58785   SwigDirector_ViewImpl *darg = 0;
58786   bool result;
58787
58788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58789   arg2 = (Dali::Dimension::Type)jarg2;
58790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58791   {
58792     try {
58793       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
58794     } catch (std::out_of_range& e) {
58795       {
58796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58797       };
58798     } catch (std::exception& e) {
58799       {
58800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58801       };
58802     } catch (...) {
58803       {
58804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58805       };
58806     }
58807   }
58808   jresult = result;
58809   return jresult;
58810 }
58811
58812
58813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
58814   unsigned int jresult ;
58815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58816   Dali::Dimension::Type arg2 ;
58817   SwigDirector_ViewImpl *darg = 0;
58818   bool result;
58819
58820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58821   arg2 = (Dali::Dimension::Type)jarg2;
58822   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58823   {
58824     try {
58825       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
58826     } catch (std::out_of_range& e) {
58827       {
58828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58829       };
58830     } catch (std::exception& e) {
58831       {
58832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58833       };
58834     } catch (...) {
58835       {
58836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58837       };
58838     }
58839   }
58840   jresult = result;
58841   return jresult;
58842 }
58843
58844
58845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
58846   unsigned int jresult ;
58847   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58848   SwigDirector_ViewImpl *darg = 0;
58849   bool result;
58850
58851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58853   {
58854     try {
58855       result = (bool)(darg)->RelayoutDependentOnChildren();
58856     } catch (std::out_of_range& e) {
58857       {
58858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58859       };
58860     } catch (std::exception& e) {
58861       {
58862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58863       };
58864     } catch (...) {
58865       {
58866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58867       };
58868     }
58869   }
58870   jresult = result;
58871   return jresult;
58872 }
58873
58874
58875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
58876   unsigned int jresult ;
58877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58878   SwigDirector_ViewImpl *darg = 0;
58879   bool result;
58880
58881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58882   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58883   {
58884     try {
58885       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
58886     } catch (std::out_of_range& e) {
58887       {
58888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58889       };
58890     } catch (std::exception& e) {
58891       {
58892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58893       };
58894     } catch (...) {
58895       {
58896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58897       };
58898     }
58899   }
58900   jresult = result;
58901   return jresult;
58902 }
58903
58904
58905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
58906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58907   Dali::Dimension::Type arg2 ;
58908   SwigDirector_ViewImpl *darg = 0;
58909
58910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58911   arg2 = (Dali::Dimension::Type)jarg2;
58912   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58913   {
58914     try {
58915       (darg)->OnCalculateRelayoutSize(arg2);
58916     } catch (std::out_of_range& e) {
58917       {
58918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58919       };
58920     } catch (std::exception& e) {
58921       {
58922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58923       };
58924     } catch (...) {
58925       {
58926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58927       };
58928     }
58929   }
58930 }
58931
58932
58933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
58934   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58935   Dali::Dimension::Type arg2 ;
58936   SwigDirector_ViewImpl *darg = 0;
58937
58938   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58939   arg2 = (Dali::Dimension::Type)jarg2;
58940   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58941   {
58942     try {
58943       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
58944     } catch (std::out_of_range& e) {
58945       {
58946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58947       };
58948     } catch (std::exception& e) {
58949       {
58950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58951       };
58952     } catch (...) {
58953       {
58954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58955       };
58956     }
58957   }
58958 }
58959
58960
58961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
58962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58963   float arg2 ;
58964   Dali::Dimension::Type arg3 ;
58965   SwigDirector_ViewImpl *darg = 0;
58966
58967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58968   arg2 = (float)jarg2;
58969   arg3 = (Dali::Dimension::Type)jarg3;
58970   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58971   {
58972     try {
58973       (darg)->OnLayoutNegotiated(arg2,arg3);
58974     } catch (std::out_of_range& e) {
58975       {
58976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58977       };
58978     } catch (std::exception& e) {
58979       {
58980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58981       };
58982     } catch (...) {
58983       {
58984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58985       };
58986     }
58987   }
58988 }
58989
58990
58991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
58992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58993   float arg2 ;
58994   Dali::Dimension::Type arg3 ;
58995   SwigDirector_ViewImpl *darg = 0;
58996
58997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58998   arg2 = (float)jarg2;
58999   arg3 = (Dali::Dimension::Type)jarg3;
59000   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59001   {
59002     try {
59003       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
59004     } catch (std::out_of_range& e) {
59005       {
59006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59007       };
59008     } catch (std::exception& e) {
59009       {
59010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59011       };
59012     } catch (...) {
59013       {
59014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59015       };
59016     }
59017   }
59018 }
59019
59020
59021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
59022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59023
59024   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59025   {
59026     try {
59027       (arg1)->OnInitialize();
59028     } catch (std::out_of_range& e) {
59029       {
59030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59031       };
59032     } catch (std::exception& e) {
59033       {
59034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59035       };
59036     } catch (...) {
59037       {
59038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59039       };
59040     }
59041   }
59042 }
59043
59044
59045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
59046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59047
59048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59049   {
59050     try {
59051       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
59052     } catch (std::out_of_range& e) {
59053       {
59054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59055       };
59056     } catch (std::exception& e) {
59057       {
59058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59059       };
59060     } catch (...) {
59061       {
59062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59063       };
59064     }
59065   }
59066 }
59067
59068
59069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
59070   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59071   Dali::Actor *arg2 = 0 ;
59072
59073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59074   arg2 = (Dali::Actor *)jarg2;
59075   if (!arg2) {
59076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59077     return ;
59078   }
59079   {
59080     try {
59081       (arg1)->OnControlChildAdd(*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_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59101   Dali::Actor *arg2 = 0 ;
59102
59103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59104   arg2 = (Dali::Actor *)jarg2;
59105   if (!arg2) {
59106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59107     return ;
59108   }
59109   {
59110     try {
59111       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
59112     } catch (std::out_of_range& e) {
59113       {
59114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59115       };
59116     } catch (std::exception& e) {
59117       {
59118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59119       };
59120     } catch (...) {
59121       {
59122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59123       };
59124     }
59125   }
59126 }
59127
59128
59129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
59130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59131   Dali::Actor *arg2 = 0 ;
59132
59133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59134   arg2 = (Dali::Actor *)jarg2;
59135   if (!arg2) {
59136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59137     return ;
59138   }
59139   {
59140     try {
59141       (arg1)->OnControlChildRemove(*arg2);
59142     } catch (std::out_of_range& e) {
59143       {
59144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59145       };
59146     } catch (std::exception& e) {
59147       {
59148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59149       };
59150     } catch (...) {
59151       {
59152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59153       };
59154     }
59155   }
59156 }
59157
59158
59159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59161   Dali::Actor *arg2 = 0 ;
59162
59163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59164   arg2 = (Dali::Actor *)jarg2;
59165   if (!arg2) {
59166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59167     return ;
59168   }
59169   {
59170     try {
59171       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
59172     } catch (std::out_of_range& e) {
59173       {
59174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59175       };
59176     } catch (std::exception& e) {
59177       {
59178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59179       };
59180     } catch (...) {
59181       {
59182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59183       };
59184     }
59185   }
59186 }
59187
59188
59189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
59190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59191   Dali::Toolkit::StyleManager arg2 ;
59192   Dali::StyleChange::Type arg3 ;
59193   Dali::Toolkit::StyleManager *argp2 ;
59194
59195   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59196   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
59197   if (!argp2) {
59198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
59199     return ;
59200   }
59201   arg2 = *argp2;
59202   arg3 = (Dali::StyleChange::Type)jarg3;
59203   {
59204     try {
59205       (arg1)->OnStyleChange(arg2,arg3);
59206     } catch (std::out_of_range& e) {
59207       {
59208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59209       };
59210     } catch (std::exception& e) {
59211       {
59212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59213       };
59214     } catch (...) {
59215       {
59216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59217       };
59218     }
59219   }
59220 }
59221
59222
59223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
59224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59225   Dali::Toolkit::StyleManager arg2 ;
59226   Dali::StyleChange::Type arg3 ;
59227   Dali::Toolkit::StyleManager *argp2 ;
59228
59229   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59230   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
59231   if (!argp2) {
59232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
59233     return ;
59234   }
59235   arg2 = *argp2;
59236   arg3 = (Dali::StyleChange::Type)jarg3;
59237   {
59238     try {
59239       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
59240     } catch (std::out_of_range& e) {
59241       {
59242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59243       };
59244     } catch (std::exception& e) {
59245       {
59246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59247       };
59248     } catch (...) {
59249       {
59250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59251       };
59252     }
59253   }
59254 }
59255
59256
59257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
59258   unsigned int jresult ;
59259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59260   bool result;
59261
59262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59263   {
59264     try {
59265       result = (bool)(arg1)->OnAccessibilityActivated();
59266     } catch (std::out_of_range& e) {
59267       {
59268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59269       };
59270     } catch (std::exception& e) {
59271       {
59272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59273       };
59274     } catch (...) {
59275       {
59276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59277       };
59278     }
59279   }
59280   jresult = result;
59281   return jresult;
59282 }
59283
59284
59285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
59286   unsigned int jresult ;
59287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59288   bool result;
59289
59290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59291   {
59292     try {
59293       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
59294     } catch (std::out_of_range& e) {
59295       {
59296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59297       };
59298     } catch (std::exception& e) {
59299       {
59300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59301       };
59302     } catch (...) {
59303       {
59304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59305       };
59306     }
59307   }
59308   jresult = result;
59309   return jresult;
59310 }
59311
59312
59313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
59314   unsigned int jresult ;
59315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59316   Dali::PanGesture arg2 ;
59317   Dali::PanGesture *argp2 ;
59318   bool result;
59319
59320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59321   argp2 = (Dali::PanGesture *)jarg2;
59322   if (!argp2) {
59323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
59324     return 0;
59325   }
59326   arg2 = *argp2;
59327   {
59328     try {
59329       result = (bool)(arg1)->OnAccessibilityPan(arg2);
59330     } catch (std::out_of_range& e) {
59331       {
59332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59333       };
59334     } catch (std::exception& e) {
59335       {
59336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59337       };
59338     } catch (...) {
59339       {
59340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59341       };
59342     }
59343   }
59344   jresult = result;
59345   return jresult;
59346 }
59347
59348
59349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59350   unsigned int jresult ;
59351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59352   Dali::PanGesture arg2 ;
59353   Dali::PanGesture *argp2 ;
59354   bool result;
59355
59356   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59357   argp2 = (Dali::PanGesture *)jarg2;
59358   if (!argp2) {
59359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
59360     return 0;
59361   }
59362   arg2 = *argp2;
59363   {
59364     try {
59365       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
59366     } catch (std::out_of_range& e) {
59367       {
59368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59369       };
59370     } catch (std::exception& e) {
59371       {
59372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59373       };
59374     } catch (...) {
59375       {
59376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59377       };
59378     }
59379   }
59380   jresult = result;
59381   return jresult;
59382 }
59383
59384
59385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
59386   unsigned int jresult ;
59387   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59388   Dali::TouchEvent *arg2 = 0 ;
59389   bool result;
59390
59391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59392   arg2 = (Dali::TouchEvent *)jarg2;
59393   if (!arg2) {
59394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59395     return 0;
59396   }
59397   {
59398     try {
59399       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
59400     } catch (std::out_of_range& e) {
59401       {
59402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59403       };
59404     } catch (std::exception& e) {
59405       {
59406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59407       };
59408     } catch (...) {
59409       {
59410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59411       };
59412     }
59413   }
59414   jresult = result;
59415   return jresult;
59416 }
59417
59418
59419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59420   unsigned int jresult ;
59421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59422   Dali::TouchEvent *arg2 = 0 ;
59423   bool result;
59424
59425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59426   arg2 = (Dali::TouchEvent *)jarg2;
59427   if (!arg2) {
59428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59429     return 0;
59430   }
59431   {
59432     try {
59433       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
59434     } catch (std::out_of_range& e) {
59435       {
59436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59437       };
59438     } catch (std::exception& e) {
59439       {
59440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59441       };
59442     } catch (...) {
59443       {
59444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59445       };
59446     }
59447   }
59448   jresult = result;
59449   return jresult;
59450 }
59451
59452
59453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
59454   unsigned int jresult ;
59455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59456   bool arg2 ;
59457   bool result;
59458
59459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59460   arg2 = jarg2 ? true : false;
59461   {
59462     try {
59463       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
59464     } catch (std::out_of_range& e) {
59465       {
59466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59467       };
59468     } catch (std::exception& e) {
59469       {
59470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59471       };
59472     } catch (...) {
59473       {
59474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59475       };
59476     }
59477   }
59478   jresult = result;
59479   return jresult;
59480 }
59481
59482
59483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
59484   unsigned int jresult ;
59485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59486   bool arg2 ;
59487   bool result;
59488
59489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59490   arg2 = jarg2 ? true : false;
59491   {
59492     try {
59493       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
59494     } catch (std::out_of_range& e) {
59495       {
59496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59497       };
59498     } catch (std::exception& e) {
59499       {
59500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59501       };
59502     } catch (...) {
59503       {
59504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59505       };
59506     }
59507   }
59508   jresult = result;
59509   return jresult;
59510 }
59511
59512
59513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
59514   unsigned int jresult ;
59515   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59516   bool result;
59517
59518   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59519   {
59520     try {
59521       result = (bool)(arg1)->OnAccessibilityZoom();
59522     } catch (std::out_of_range& e) {
59523       {
59524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59525       };
59526     } catch (std::exception& e) {
59527       {
59528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59529       };
59530     } catch (...) {
59531       {
59532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59533       };
59534     }
59535   }
59536   jresult = result;
59537   return jresult;
59538 }
59539
59540
59541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
59542   unsigned int jresult ;
59543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59544   bool result;
59545
59546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59547   {
59548     try {
59549       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
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 = result;
59565   return jresult;
59566 }
59567
59568
59569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
59570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59571
59572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59573   {
59574     try {
59575       (arg1)->OnKeyInputFocusGained();
59576     } catch (std::out_of_range& e) {
59577       {
59578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59579       };
59580     } catch (std::exception& e) {
59581       {
59582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59583       };
59584     } catch (...) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59587       };
59588     }
59589   }
59590 }
59591
59592
59593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
59594   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59595
59596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59597   {
59598     try {
59599       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
59600     } catch (std::out_of_range& e) {
59601       {
59602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59603       };
59604     } catch (std::exception& e) {
59605       {
59606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59607       };
59608     } catch (...) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59611       };
59612     }
59613   }
59614 }
59615
59616
59617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
59618   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59619
59620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59621   {
59622     try {
59623       (arg1)->OnKeyInputFocusLost();
59624     } catch (std::out_of_range& e) {
59625       {
59626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59627       };
59628     } catch (std::exception& e) {
59629       {
59630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59631       };
59632     } catch (...) {
59633       {
59634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59635       };
59636     }
59637   }
59638 }
59639
59640
59641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
59642   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59643
59644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59645   {
59646     try {
59647       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
59648     } catch (std::out_of_range& e) {
59649       {
59650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59651       };
59652     } catch (std::exception& e) {
59653       {
59654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59655       };
59656     } catch (...) {
59657       {
59658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59659       };
59660     }
59661   }
59662 }
59663
59664
59665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
59666   void * jresult ;
59667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59668   Dali::Actor arg2 ;
59669   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
59670   bool arg4 ;
59671   Dali::Actor *argp2 ;
59672   Dali::Actor result;
59673
59674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59675   argp2 = (Dali::Actor *)jarg2;
59676   if (!argp2) {
59677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59678     return 0;
59679   }
59680   arg2 = *argp2;
59681   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
59682   arg4 = jarg4 ? true : false;
59683   {
59684     try {
59685       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
59686     } catch (std::out_of_range& e) {
59687       {
59688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59689       };
59690     } catch (std::exception& e) {
59691       {
59692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59693       };
59694     } catch (...) {
59695       {
59696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59697       };
59698     }
59699   }
59700   jresult = new Dali::Actor((const Dali::Actor &)result);
59701   return jresult;
59702 }
59703
59704
59705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
59706   void * jresult ;
59707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59708   Dali::Actor arg2 ;
59709   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
59710   bool arg4 ;
59711   Dali::Actor *argp2 ;
59712   Dali::Actor result;
59713
59714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59715   argp2 = (Dali::Actor *)jarg2;
59716   if (!argp2) {
59717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59718     return 0;
59719   }
59720   arg2 = *argp2;
59721   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
59722   arg4 = jarg4 ? true : false;
59723   {
59724     try {
59725       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
59726     } catch (std::out_of_range& e) {
59727       {
59728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59729       };
59730     } catch (std::exception& e) {
59731       {
59732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59733       };
59734     } catch (...) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59737       };
59738     }
59739   }
59740   jresult = new Dali::Actor((const Dali::Actor &)result);
59741   return jresult;
59742 }
59743
59744
59745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
59746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59747   Dali::Actor arg2 ;
59748   Dali::Actor *argp2 ;
59749
59750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59751   argp2 = (Dali::Actor *)jarg2;
59752   if (!argp2) {
59753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59754     return ;
59755   }
59756   arg2 = *argp2;
59757   {
59758     try {
59759       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
59760     } catch (std::out_of_range& e) {
59761       {
59762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59763       };
59764     } catch (std::exception& e) {
59765       {
59766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59767       };
59768     } catch (...) {
59769       {
59770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59771       };
59772     }
59773   }
59774 }
59775
59776
59777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59779   Dali::Actor arg2 ;
59780   Dali::Actor *argp2 ;
59781
59782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59783   argp2 = (Dali::Actor *)jarg2;
59784   if (!argp2) {
59785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59786     return ;
59787   }
59788   arg2 = *argp2;
59789   {
59790     try {
59791       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
59792     } catch (std::out_of_range& e) {
59793       {
59794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59795       };
59796     } catch (std::exception& e) {
59797       {
59798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59799       };
59800     } catch (...) {
59801       {
59802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59803       };
59804     }
59805   }
59806 }
59807
59808
59809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
59810   unsigned int jresult ;
59811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59812   bool result;
59813
59814   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59815   {
59816     try {
59817       result = (bool)(arg1)->OnKeyboardEnter();
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 = result;
59833   return jresult;
59834 }
59835
59836
59837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
59838   unsigned int jresult ;
59839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59840   bool result;
59841
59842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59843   {
59844     try {
59845       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
59846     } catch (std::out_of_range& e) {
59847       {
59848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59849       };
59850     } catch (std::exception& e) {
59851       {
59852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59853       };
59854     } catch (...) {
59855       {
59856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59857       };
59858     }
59859   }
59860   jresult = result;
59861   return jresult;
59862 }
59863
59864
59865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
59866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59867   Dali::PinchGesture *arg2 = 0 ;
59868
59869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59870   arg2 = (Dali::PinchGesture *)jarg2;
59871   if (!arg2) {
59872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
59873     return ;
59874   }
59875   {
59876     try {
59877       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
59878     } catch (std::out_of_range& e) {
59879       {
59880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59881       };
59882     } catch (std::exception& e) {
59883       {
59884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59885       };
59886     } catch (...) {
59887       {
59888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59889       };
59890     }
59891   }
59892 }
59893
59894
59895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59897   Dali::PinchGesture *arg2 = 0 ;
59898
59899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59900   arg2 = (Dali::PinchGesture *)jarg2;
59901   if (!arg2) {
59902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
59903     return ;
59904   }
59905   {
59906     try {
59907       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
59908     } catch (std::out_of_range& e) {
59909       {
59910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59911       };
59912     } catch (std::exception& e) {
59913       {
59914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59915       };
59916     } catch (...) {
59917       {
59918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59919       };
59920     }
59921   }
59922 }
59923
59924
59925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
59926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59927   Dali::PanGesture *arg2 = 0 ;
59928
59929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59930   arg2 = (Dali::PanGesture *)jarg2;
59931   if (!arg2) {
59932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
59933     return ;
59934   }
59935   {
59936     try {
59937       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
59938     } catch (std::out_of_range& e) {
59939       {
59940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59941       };
59942     } catch (std::exception& e) {
59943       {
59944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59945       };
59946     } catch (...) {
59947       {
59948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59949       };
59950     }
59951   }
59952 }
59953
59954
59955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59957   Dali::PanGesture *arg2 = 0 ;
59958
59959   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59960   arg2 = (Dali::PanGesture *)jarg2;
59961   if (!arg2) {
59962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
59963     return ;
59964   }
59965   {
59966     try {
59967       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
59968     } catch (std::out_of_range& e) {
59969       {
59970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59971       };
59972     } catch (std::exception& e) {
59973       {
59974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59975       };
59976     } catch (...) {
59977       {
59978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59979       };
59980     }
59981   }
59982 }
59983
59984
59985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
59986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59987   Dali::TapGesture *arg2 = 0 ;
59988
59989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59990   arg2 = (Dali::TapGesture *)jarg2;
59991   if (!arg2) {
59992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
59993     return ;
59994   }
59995   {
59996     try {
59997       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
59998     } catch (std::out_of_range& e) {
59999       {
60000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60001       };
60002     } catch (std::exception& e) {
60003       {
60004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60005       };
60006     } catch (...) {
60007       {
60008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60009       };
60010     }
60011   }
60012 }
60013
60014
60015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60017   Dali::TapGesture *arg2 = 0 ;
60018
60019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60020   arg2 = (Dali::TapGesture *)jarg2;
60021   if (!arg2) {
60022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
60023     return ;
60024   }
60025   {
60026     try {
60027       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
60028     } catch (std::out_of_range& e) {
60029       {
60030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60031       };
60032     } catch (std::exception& e) {
60033       {
60034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60035       };
60036     } catch (...) {
60037       {
60038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60039       };
60040     }
60041   }
60042 }
60043
60044
60045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
60046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60047   Dali::LongPressGesture *arg2 = 0 ;
60048
60049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60050   arg2 = (Dali::LongPressGesture *)jarg2;
60051   if (!arg2) {
60052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
60053     return ;
60054   }
60055   {
60056     try {
60057       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
60058     } catch (std::out_of_range& e) {
60059       {
60060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60061       };
60062     } catch (std::exception& e) {
60063       {
60064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60065       };
60066     } catch (...) {
60067       {
60068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60069       };
60070     }
60071   }
60072 }
60073
60074
60075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60077   Dali::LongPressGesture *arg2 = 0 ;
60078
60079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60080   arg2 = (Dali::LongPressGesture *)jarg2;
60081   if (!arg2) {
60082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
60083     return ;
60084   }
60085   {
60086     try {
60087       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
60088     } catch (std::out_of_range& e) {
60089       {
60090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60091       };
60092     } catch (std::exception& e) {
60093       {
60094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60099       };
60100     }
60101   }
60102 }
60103
60104
60105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
60106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60107   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60108   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60109
60110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60111   arg2 = (Dali::SlotObserver *)jarg2;
60112   arg3 = (Dali::CallbackBase *)jarg3;
60113   {
60114     try {
60115       (arg1)->SignalConnected(arg2,arg3);
60116     } catch (std::out_of_range& e) {
60117       {
60118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60119       };
60120     } catch (std::exception& e) {
60121       {
60122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60123       };
60124     } catch (...) {
60125       {
60126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60127       };
60128     }
60129   }
60130 }
60131
60132
60133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60135   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60136   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60137
60138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60139   arg2 = (Dali::SlotObserver *)jarg2;
60140   arg3 = (Dali::CallbackBase *)jarg3;
60141   {
60142     try {
60143       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
60144     } catch (std::out_of_range& e) {
60145       {
60146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60147       };
60148     } catch (std::exception& e) {
60149       {
60150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60151       };
60152     } catch (...) {
60153       {
60154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60155       };
60156     }
60157   }
60158 }
60159
60160
60161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
60162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60163   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60164   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60165
60166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60167   arg2 = (Dali::SlotObserver *)jarg2;
60168   arg3 = (Dali::CallbackBase *)jarg3;
60169   {
60170     try {
60171       (arg1)->SignalDisconnected(arg2,arg3);
60172     } catch (std::out_of_range& e) {
60173       {
60174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60175       };
60176     } catch (std::exception& e) {
60177       {
60178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60179       };
60180     } catch (...) {
60181       {
60182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60183       };
60184     }
60185   }
60186 }
60187
60188
60189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60191   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60192   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60193
60194   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60195   arg2 = (Dali::SlotObserver *)jarg2;
60196   arg3 = (Dali::CallbackBase *)jarg3;
60197   {
60198     try {
60199       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
60200     } catch (std::out_of_range& e) {
60201       {
60202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60203       };
60204     } catch (std::exception& e) {
60205       {
60206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60207       };
60208     } catch (...) {
60209       {
60210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60211       };
60212     }
60213   }
60214 }
60215
60216
60217 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) {
60218   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
60219   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
60220   if (director) {
60221     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);
60222   }
60223 }
60224
60225
60226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
60227   void * jresult ;
60228   Dali::Toolkit::Control *arg1 = 0 ;
60229   Dali::Toolkit::Internal::Control *result = 0 ;
60230
60231   arg1 = (Dali::Toolkit::Control *)jarg1;
60232   if (!arg1) {
60233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
60234     return 0;
60235   }
60236   {
60237     try {
60238       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
60239     } catch (std::out_of_range& e) {
60240       {
60241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60242       };
60243     } catch (std::exception& e) {
60244       {
60245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60246       };
60247     } catch (...) {
60248       {
60249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60250       };
60251     }
60252   }
60253   jresult = (void *)result;
60254   return jresult;
60255 }
60256
60257
60258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
60259   int jresult ;
60260   int result;
60261
60262   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
60263   jresult = (int)result;
60264   return jresult;
60265 }
60266
60267
60268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
60269   int jresult ;
60270   int result;
60271
60272   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
60273   jresult = (int)result;
60274   return jresult;
60275 }
60276
60277
60278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
60279   int jresult ;
60280   int result;
60281
60282   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
60283   jresult = (int)result;
60284   return jresult;
60285 }
60286
60287
60288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
60289   int jresult ;
60290   int result;
60291
60292   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
60293   jresult = (int)result;
60294   return jresult;
60295 }
60296
60297
60298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
60299   int jresult ;
60300   int result;
60301
60302   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
60303   jresult = (int)result;
60304   return jresult;
60305 }
60306
60307
60308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
60309   void * jresult ;
60310   Dali::Toolkit::Control::Property *result = 0 ;
60311
60312   {
60313     try {
60314       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
60315     } catch (std::out_of_range& e) {
60316       {
60317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60318       };
60319     } catch (std::exception& e) {
60320       {
60321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60322       };
60323     } catch (...) {
60324       {
60325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60326       };
60327     }
60328   }
60329   jresult = (void *)result;
60330   return jresult;
60331 }
60332
60333
60334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
60335   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
60336
60337   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
60338   {
60339     try {
60340       delete arg1;
60341     } catch (std::out_of_range& e) {
60342       {
60343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60344       };
60345     } catch (std::exception& e) {
60346       {
60347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60348       };
60349     } catch (...) {
60350       {
60351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60352       };
60353     }
60354   }
60355 }
60356
60357
60358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
60359   void * jresult ;
60360   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
60361
60362   {
60363     try {
60364       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
60365     } catch (std::out_of_range& e) {
60366       {
60367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60368       };
60369     } catch (std::exception& e) {
60370       {
60371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60372       };
60373     } catch (...) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60376       };
60377     }
60378   }
60379   jresult = (void *)result;
60380   return jresult;
60381 }
60382
60383
60384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
60385   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
60386
60387   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
60388   {
60389     try {
60390       delete arg1;
60391     } catch (std::out_of_range& e) {
60392       {
60393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60394       };
60395     } catch (std::exception& e) {
60396       {
60397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60398       };
60399     } catch (...) {
60400       {
60401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60402       };
60403     }
60404   }
60405 }
60406
60407
60408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
60409   void * jresult ;
60410   Dali::Toolkit::Control result;
60411
60412   {
60413     try {
60414       result = Dali::Toolkit::Control::New();
60415     } catch (std::out_of_range& e) {
60416       {
60417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60418       };
60419     } catch (std::exception& e) {
60420       {
60421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60422       };
60423     } catch (...) {
60424       {
60425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60426       };
60427     }
60428   }
60429   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60430   return jresult;
60431 }
60432
60433
60434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
60435   void * jresult ;
60436   Dali::Toolkit::Control *result = 0 ;
60437
60438   {
60439     try {
60440       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
60441     } catch (std::out_of_range& e) {
60442       {
60443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60444       };
60445     } catch (std::exception& e) {
60446       {
60447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60448       };
60449     } catch (...) {
60450       {
60451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60452       };
60453     }
60454   }
60455   jresult = (void *)result;
60456   return jresult;
60457 }
60458
60459
60460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
60461   void * jresult ;
60462   Dali::Toolkit::Control *arg1 = 0 ;
60463   Dali::Toolkit::Control *result = 0 ;
60464
60465   arg1 = (Dali::Toolkit::Control *)jarg1;
60466   if (!arg1) {
60467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
60468     return 0;
60469   }
60470   {
60471     try {
60472       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
60473     } catch (std::out_of_range& e) {
60474       {
60475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60476       };
60477     } catch (std::exception& e) {
60478       {
60479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60480       };
60481     } catch (...) {
60482       {
60483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60484       };
60485     }
60486   }
60487   jresult = (void *)result;
60488   return jresult;
60489 }
60490
60491
60492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
60493   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60494
60495   arg1 = (Dali::Toolkit::Control *)jarg1;
60496   {
60497     try {
60498       delete arg1;
60499     } catch (std::out_of_range& e) {
60500       {
60501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60502       };
60503     } catch (std::exception& e) {
60504       {
60505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60506       };
60507     } catch (...) {
60508       {
60509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60510       };
60511     }
60512   }
60513 }
60514
60515
60516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
60517   void * jresult ;
60518   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60519   Dali::Toolkit::Control *arg2 = 0 ;
60520   Dali::Toolkit::Control *result = 0 ;
60521
60522   arg1 = (Dali::Toolkit::Control *)jarg1;
60523   arg2 = (Dali::Toolkit::Control *)jarg2;
60524   if (!arg2) {
60525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
60526     return 0;
60527   }
60528   {
60529     try {
60530       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
60531     } catch (std::out_of_range& e) {
60532       {
60533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60534       };
60535     } catch (std::exception& e) {
60536       {
60537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60538       };
60539     } catch (...) {
60540       {
60541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60542       };
60543     }
60544   }
60545   jresult = (void *)result;
60546   return jresult;
60547 }
60548
60549
60550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
60551   void * jresult ;
60552   Dali::BaseHandle arg1 ;
60553   Dali::BaseHandle *argp1 ;
60554   Dali::Toolkit::Control result;
60555
60556   argp1 = (Dali::BaseHandle *)jarg1;
60557   if (!argp1) {
60558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60559     return 0;
60560   }
60561   arg1 = *argp1;
60562   {
60563     try {
60564       result = Dali::Toolkit::Control::DownCast(arg1);
60565     } catch (std::out_of_range& e) {
60566       {
60567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60568       };
60569     } catch (std::exception& e) {
60570       {
60571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60572       };
60573     } catch (...) {
60574       {
60575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60576       };
60577     }
60578   }
60579   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60580   return jresult;
60581 }
60582
60583
60584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
60585   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60586
60587   arg1 = (Dali::Toolkit::Control *)jarg1;
60588   {
60589     try {
60590       (arg1)->SetKeyInputFocus();
60591     } catch (std::out_of_range& e) {
60592       {
60593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60594       };
60595     } catch (std::exception& e) {
60596       {
60597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60598       };
60599     } catch (...) {
60600       {
60601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60602       };
60603     }
60604   }
60605 }
60606
60607
60608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
60609   unsigned int jresult ;
60610   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60611   bool result;
60612
60613   arg1 = (Dali::Toolkit::Control *)jarg1;
60614   {
60615     try {
60616       result = (bool)(arg1)->HasKeyInputFocus();
60617     } catch (std::out_of_range& e) {
60618       {
60619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60620       };
60621     } catch (std::exception& e) {
60622       {
60623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60624       };
60625     } catch (...) {
60626       {
60627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60628       };
60629     }
60630   }
60631   jresult = result;
60632   return jresult;
60633 }
60634
60635
60636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
60637   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60638
60639   arg1 = (Dali::Toolkit::Control *)jarg1;
60640   {
60641     try {
60642       (arg1)->ClearKeyInputFocus();
60643     } catch (std::out_of_range& e) {
60644       {
60645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60646       };
60647     } catch (std::exception& e) {
60648       {
60649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60650       };
60651     } catch (...) {
60652       {
60653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60654       };
60655     }
60656   }
60657 }
60658
60659
60660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
60661   void * jresult ;
60662   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60663   Dali::PinchGestureDetector result;
60664
60665   arg1 = (Dali::Toolkit::Control *)jarg1;
60666   {
60667     try {
60668       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
60669     } catch (std::out_of_range& e) {
60670       {
60671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60672       };
60673     } catch (std::exception& e) {
60674       {
60675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60676       };
60677     } catch (...) {
60678       {
60679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60680       };
60681     }
60682   }
60683   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60684   return jresult;
60685 }
60686
60687
60688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
60689   void * jresult ;
60690   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60691   Dali::PanGestureDetector result;
60692
60693   arg1 = (Dali::Toolkit::Control *)jarg1;
60694   {
60695     try {
60696       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
60697     } catch (std::out_of_range& e) {
60698       {
60699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60700       };
60701     } catch (std::exception& e) {
60702       {
60703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60704       };
60705     } catch (...) {
60706       {
60707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60708       };
60709     }
60710   }
60711   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60712   return jresult;
60713 }
60714
60715
60716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
60717   void * jresult ;
60718   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60719   Dali::TapGestureDetector result;
60720
60721   arg1 = (Dali::Toolkit::Control *)jarg1;
60722   {
60723     try {
60724       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
60725     } catch (std::out_of_range& e) {
60726       {
60727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60728       };
60729     } catch (std::exception& e) {
60730       {
60731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60732       };
60733     } catch (...) {
60734       {
60735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60736       };
60737     }
60738   }
60739   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60740   return jresult;
60741 }
60742
60743
60744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
60745   void * jresult ;
60746   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60747   Dali::LongPressGestureDetector result;
60748
60749   arg1 = (Dali::Toolkit::Control *)jarg1;
60750   {
60751     try {
60752       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
60753     } catch (std::out_of_range& e) {
60754       {
60755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60756       };
60757     } catch (std::exception& e) {
60758       {
60759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60760       };
60761     } catch (...) {
60762       {
60763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60764       };
60765     }
60766   }
60767   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60768   return jresult;
60769 }
60770
60771
60772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
60773   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60774   std::string *arg2 = 0 ;
60775
60776   arg1 = (Dali::Toolkit::Control *)jarg1;
60777   if (!jarg2) {
60778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60779     return ;
60780   }
60781   std::string arg2_str(jarg2);
60782   arg2 = &arg2_str;
60783   {
60784     try {
60785       (arg1)->SetStyleName((std::string const &)*arg2);
60786     } catch (std::out_of_range& e) {
60787       {
60788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60789       };
60790     } catch (std::exception& e) {
60791       {
60792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60793       };
60794     } catch (...) {
60795       {
60796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60797       };
60798     }
60799   }
60800
60801   //argout typemap for const std::string&
60802
60803 }
60804
60805
60806 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
60807   char * jresult ;
60808   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60809   std::string *result = 0 ;
60810
60811   arg1 = (Dali::Toolkit::Control *)jarg1;
60812   {
60813     try {
60814       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
60815     } catch (std::out_of_range& e) {
60816       {
60817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60818       };
60819     } catch (std::exception& e) {
60820       {
60821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60822       };
60823     } catch (...) {
60824       {
60825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60826       };
60827     }
60828   }
60829   jresult = SWIG_csharp_string_callback(result->c_str());
60830   return jresult;
60831 }
60832
60833
60834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
60835   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60836   Dali::Vector4 *arg2 = 0 ;
60837
60838   arg1 = (Dali::Toolkit::Control *)jarg1;
60839   arg2 = (Dali::Vector4 *)jarg2;
60840   if (!arg2) {
60841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60842     return ;
60843   }
60844   {
60845     try {
60846       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60847     } catch (std::out_of_range& e) {
60848       {
60849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60850       };
60851     } catch (std::exception& e) {
60852       {
60853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60854       };
60855     } catch (...) {
60856       {
60857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60858       };
60859     }
60860   }
60861 }
60862
60863
60864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
60865   void * jresult ;
60866   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60867   Dali::Vector4 result;
60868
60869   arg1 = (Dali::Toolkit::Control *)jarg1;
60870   {
60871     try {
60872       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
60873     } catch (std::out_of_range& e) {
60874       {
60875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60876       };
60877     } catch (std::exception& e) {
60878       {
60879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60880       };
60881     } catch (...) {
60882       {
60883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60884       };
60885     }
60886   }
60887   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60888   return jresult;
60889 }
60890
60891
60892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
60893   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60894   Dali::Image arg2 ;
60895   Dali::Image *argp2 ;
60896
60897   arg1 = (Dali::Toolkit::Control *)jarg1;
60898   argp2 = (Dali::Image *)jarg2;
60899   if (!argp2) {
60900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60901     return ;
60902   }
60903   arg2 = *argp2;
60904   {
60905     try {
60906       (arg1)->SetBackgroundImage(arg2);
60907     } catch (std::out_of_range& e) {
60908       {
60909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60910       };
60911     } catch (std::exception& e) {
60912       {
60913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60914       };
60915     } catch (...) {
60916       {
60917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60918       };
60919     }
60920   }
60921 }
60922
60923
60924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
60925   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60926
60927   arg1 = (Dali::Toolkit::Control *)jarg1;
60928   {
60929     try {
60930       (arg1)->ClearBackground();
60931     } catch (std::out_of_range& e) {
60932       {
60933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60934       };
60935     } catch (std::exception& e) {
60936       {
60937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60938       };
60939     } catch (...) {
60940       {
60941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60942       };
60943     }
60944   }
60945 }
60946
60947
60948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
60949   void * jresult ;
60950   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60951   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60952
60953   arg1 = (Dali::Toolkit::Control *)jarg1;
60954   {
60955     try {
60956       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60957     } catch (std::out_of_range& e) {
60958       {
60959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60960       };
60961     } catch (std::exception& e) {
60962       {
60963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60964       };
60965     } catch (...) {
60966       {
60967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60968       };
60969     }
60970   }
60971   jresult = (void *)result;
60972   return jresult;
60973 }
60974
60975
60976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
60977   void * jresult ;
60978   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60979   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60980
60981   arg1 = (Dali::Toolkit::Control *)jarg1;
60982   {
60983     try {
60984       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60985     } catch (std::out_of_range& e) {
60986       {
60987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60988       };
60989     } catch (std::exception& e) {
60990       {
60991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (...) {
60994       {
60995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60996       };
60997     }
60998   }
60999   jresult = (void *)result;
61000   return jresult;
61001 }
61002
61003
61004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
61005   void * jresult ;
61006   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61007   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61008
61009   arg1 = (Dali::Toolkit::Control *)jarg1;
61010   {
61011     try {
61012       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
61013     } catch (std::out_of_range& e) {
61014       {
61015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (std::exception& e) {
61018       {
61019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61020       };
61021     } catch (...) {
61022       {
61023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61024       };
61025     }
61026   }
61027   jresult = (void *)result;
61028   return jresult;
61029 }
61030
61031
61032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
61033   void * jresult ;
61034   Dali::Toolkit::Internal::Control *arg1 = 0 ;
61035   Dali::Toolkit::Control *result = 0 ;
61036
61037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61038   if (!arg1) {
61039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
61040     return 0;
61041   }
61042   {
61043     try {
61044       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
61045     } catch (std::out_of_range& e) {
61046       {
61047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61048       };
61049     } catch (std::exception& e) {
61050       {
61051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61052       };
61053     } catch (...) {
61054       {
61055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61056       };
61057     }
61058   }
61059   jresult = (void *)result;
61060   return jresult;
61061 }
61062
61063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
61064 {
61065   void * jresult;
61066   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61067   arg1 = (Dali::Toolkit::Control *)jarg1;
61068
61069   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
61070
61071   Dali::Toolkit::TransitionData *arg2 = 0 ;
61072   Dali::Animation result;
61073
61074   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
61075   if (!arg2) {
61076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
61077     return 0;
61078   }
61079   {
61080     try {
61081       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61093       };
61094     }
61095   }
61096   jresult = new Dali::Animation((const Dali::Animation &)result);
61097   return jresult;
61098 }
61099
61100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
61101   void * jresult ;
61102   Dali::Toolkit::Control *arg1 = 0 ;
61103   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
61104
61105   arg1 = (Dali::Toolkit::Control *)jarg1;
61106   if (!arg1) {
61107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
61108     return 0;
61109   }
61110   {
61111     try {
61112       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61120       };
61121     } catch (...) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61124       };
61125     }
61126   }
61127   jresult = (void *)result;
61128   return jresult;
61129 }
61130
61131
61132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
61133   unsigned int jresult ;
61134   Dali::Toolkit::Control *arg1 = 0 ;
61135   bool result;
61136
61137   arg1 = (Dali::Toolkit::Control *)jarg1;
61138   if (!arg1) {
61139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
61140     return 0;
61141   }
61142   {
61143     try {
61144       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
61145     } catch (std::out_of_range& e) {
61146       {
61147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61148       };
61149     } catch (std::exception& e) {
61150       {
61151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61152       };
61153     } catch (...) {
61154       {
61155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61156       };
61157     }
61158   }
61159   jresult = result;
61160   return jresult;
61161 }
61162
61163
61164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
61165   void * jresult ;
61166   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
61167
61168   {
61169     try {
61170       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
61171     } catch (std::out_of_range& e) {
61172       {
61173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61174       };
61175     } catch (std::exception& e) {
61176       {
61177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (...) {
61180       {
61181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61182       };
61183     }
61184   }
61185   jresult = (void *)result;
61186   return jresult;
61187 }
61188
61189
61190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
61191   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61192
61193   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61194   {
61195     try {
61196       delete arg1;
61197     } catch (std::out_of_range& e) {
61198       {
61199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61200       };
61201     } catch (std::exception& e) {
61202       {
61203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61204       };
61205     } catch (...) {
61206       {
61207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61208       };
61209     }
61210   }
61211 }
61212
61213
61214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
61215   void * jresult ;
61216   Dali::Toolkit::KeyInputFocusManager result;
61217
61218   {
61219     try {
61220       result = Dali::Toolkit::KeyInputFocusManager::Get();
61221     } catch (std::out_of_range& e) {
61222       {
61223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61224       };
61225     } catch (std::exception& e) {
61226       {
61227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61228       };
61229     } catch (...) {
61230       {
61231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61232       };
61233     }
61234   }
61235   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
61236   return jresult;
61237 }
61238
61239
61240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
61241   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61242   Dali::Toolkit::Control arg2 ;
61243   Dali::Toolkit::Control *argp2 ;
61244
61245   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61246   argp2 = (Dali::Toolkit::Control *)jarg2;
61247   if (!argp2) {
61248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
61249     return ;
61250   }
61251   arg2 = *argp2;
61252   {
61253     try {
61254       (arg1)->SetFocus(arg2);
61255     } catch (std::out_of_range& e) {
61256       {
61257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61258       };
61259     } catch (std::exception& e) {
61260       {
61261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61262       };
61263     } catch (...) {
61264       {
61265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61266       };
61267     }
61268   }
61269 }
61270
61271
61272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
61273   void * jresult ;
61274   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61275   Dali::Toolkit::Control result;
61276
61277   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61278   {
61279     try {
61280       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
61281     } catch (std::out_of_range& e) {
61282       {
61283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61284       };
61285     } catch (std::exception& e) {
61286       {
61287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61288       };
61289     } catch (...) {
61290       {
61291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61292       };
61293     }
61294   }
61295   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
61296   return jresult;
61297 }
61298
61299
61300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
61301   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61302   Dali::Toolkit::Control arg2 ;
61303   Dali::Toolkit::Control *argp2 ;
61304
61305   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61306   argp2 = (Dali::Toolkit::Control *)jarg2;
61307   if (!argp2) {
61308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
61309     return ;
61310   }
61311   arg2 = *argp2;
61312   {
61313     try {
61314       (arg1)->RemoveFocus(arg2);
61315     } catch (std::out_of_range& e) {
61316       {
61317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61318       };
61319     } catch (std::exception& e) {
61320       {
61321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61322       };
61323     } catch (...) {
61324       {
61325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61326       };
61327     }
61328   }
61329 }
61330
61331
61332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
61333   void * jresult ;
61334   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61335   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
61336
61337   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61338   {
61339     try {
61340       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
61341     } catch (std::out_of_range& e) {
61342       {
61343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61344       };
61345     } catch (std::exception& e) {
61346       {
61347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61348       };
61349     } catch (...) {
61350       {
61351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61352       };
61353     }
61354   }
61355   jresult = (void *)result;
61356   return jresult;
61357 }
61358
61359
61360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
61361   void * jresult ;
61362   Dali::Toolkit::Alignment::Padding *result = 0 ;
61363
61364   {
61365     try {
61366       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
61367     } catch (std::out_of_range& e) {
61368       {
61369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61370       };
61371     } catch (std::exception& e) {
61372       {
61373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61374       };
61375     } catch (...) {
61376       {
61377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61378       };
61379     }
61380   }
61381   jresult = (void *)result;
61382   return jresult;
61383 }
61384
61385
61386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
61387   void * jresult ;
61388   float arg1 ;
61389   float arg2 ;
61390   float arg3 ;
61391   float arg4 ;
61392   Dali::Toolkit::Alignment::Padding *result = 0 ;
61393
61394   arg1 = (float)jarg1;
61395   arg2 = (float)jarg2;
61396   arg3 = (float)jarg3;
61397   arg4 = (float)jarg4;
61398   {
61399     try {
61400       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
61401     } catch (std::out_of_range& e) {
61402       {
61403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61404       };
61405     } catch (std::exception& e) {
61406       {
61407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61408       };
61409     } catch (...) {
61410       {
61411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61412       };
61413     }
61414   }
61415   jresult = (void *)result;
61416   return jresult;
61417 }
61418
61419
61420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
61421   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61422   float arg2 ;
61423
61424   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61425   arg2 = (float)jarg2;
61426   if (arg1) (arg1)->left = arg2;
61427 }
61428
61429
61430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
61431   float jresult ;
61432   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61433   float result;
61434
61435   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61436   result = (float) ((arg1)->left);
61437   jresult = result;
61438   return jresult;
61439 }
61440
61441
61442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
61443   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61444   float arg2 ;
61445
61446   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61447   arg2 = (float)jarg2;
61448   if (arg1) (arg1)->right = arg2;
61449 }
61450
61451
61452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
61453   float jresult ;
61454   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61455   float result;
61456
61457   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61458   result = (float) ((arg1)->right);
61459   jresult = result;
61460   return jresult;
61461 }
61462
61463
61464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
61465   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61466   float arg2 ;
61467
61468   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61469   arg2 = (float)jarg2;
61470   if (arg1) (arg1)->top = arg2;
61471 }
61472
61473
61474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
61475   float jresult ;
61476   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61477   float result;
61478
61479   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61480   result = (float) ((arg1)->top);
61481   jresult = result;
61482   return jresult;
61483 }
61484
61485
61486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
61487   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61488   float arg2 ;
61489
61490   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61491   arg2 = (float)jarg2;
61492   if (arg1) (arg1)->bottom = arg2;
61493 }
61494
61495
61496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
61497   float jresult ;
61498   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61499   float result;
61500
61501   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61502   result = (float) ((arg1)->bottom);
61503   jresult = result;
61504   return jresult;
61505 }
61506
61507
61508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
61509   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61510
61511   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61512   {
61513     try {
61514       delete arg1;
61515     } catch (std::out_of_range& e) {
61516       {
61517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61518       };
61519     } catch (std::exception& e) {
61520       {
61521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61522       };
61523     } catch (...) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61526       };
61527     }
61528   }
61529 }
61530
61531
61532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
61533   void * jresult ;
61534   Dali::Toolkit::Alignment *result = 0 ;
61535
61536   {
61537     try {
61538       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
61539     } catch (std::out_of_range& e) {
61540       {
61541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61542       };
61543     } catch (std::exception& e) {
61544       {
61545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61546       };
61547     } catch (...) {
61548       {
61549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61550       };
61551     }
61552   }
61553   jresult = (void *)result;
61554   return jresult;
61555 }
61556
61557
61558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
61559   void * jresult ;
61560   Dali::Toolkit::Alignment::Type arg1 ;
61561   Dali::Toolkit::Alignment::Type arg2 ;
61562   Dali::Toolkit::Alignment result;
61563
61564   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
61565   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
61566   {
61567     try {
61568       result = Dali::Toolkit::Alignment::New(arg1,arg2);
61569     } catch (std::out_of_range& e) {
61570       {
61571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61572       };
61573     } catch (std::exception& e) {
61574       {
61575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61576       };
61577     } catch (...) {
61578       {
61579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61580       };
61581     }
61582   }
61583   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61584   return jresult;
61585 }
61586
61587
61588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
61589   void * jresult ;
61590   Dali::Toolkit::Alignment::Type arg1 ;
61591   Dali::Toolkit::Alignment result;
61592
61593   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
61594   {
61595     try {
61596       result = Dali::Toolkit::Alignment::New(arg1);
61597     } catch (std::out_of_range& e) {
61598       {
61599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61600       };
61601     } catch (std::exception& e) {
61602       {
61603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61604       };
61605     } catch (...) {
61606       {
61607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61608       };
61609     }
61610   }
61611   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61612   return jresult;
61613 }
61614
61615
61616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
61617   void * jresult ;
61618   Dali::Toolkit::Alignment result;
61619
61620   {
61621     try {
61622       result = Dali::Toolkit::Alignment::New();
61623     } catch (std::out_of_range& e) {
61624       {
61625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61626       };
61627     } catch (std::exception& e) {
61628       {
61629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61630       };
61631     } catch (...) {
61632       {
61633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61634       };
61635     }
61636   }
61637   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61638   return jresult;
61639 }
61640
61641
61642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
61643   void * jresult ;
61644   Dali::Toolkit::Alignment *arg1 = 0 ;
61645   Dali::Toolkit::Alignment *result = 0 ;
61646
61647   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61648   if (!arg1) {
61649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
61650     return 0;
61651   }
61652   {
61653     try {
61654       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
61655     } catch (std::out_of_range& e) {
61656       {
61657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61658       };
61659     } catch (std::exception& e) {
61660       {
61661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61662       };
61663     } catch (...) {
61664       {
61665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61666       };
61667     }
61668   }
61669   jresult = (void *)result;
61670   return jresult;
61671 }
61672
61673
61674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
61675   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61676
61677   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61678   {
61679     try {
61680       delete arg1;
61681     } catch (std::out_of_range& e) {
61682       {
61683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61684       };
61685     } catch (std::exception& e) {
61686       {
61687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61688       };
61689     } catch (...) {
61690       {
61691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61692       };
61693     }
61694   }
61695 }
61696
61697
61698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
61699   void * jresult ;
61700   Dali::BaseHandle arg1 ;
61701   Dali::BaseHandle *argp1 ;
61702   Dali::Toolkit::Alignment result;
61703
61704   argp1 = (Dali::BaseHandle *)jarg1;
61705   if (!argp1) {
61706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61707     return 0;
61708   }
61709   arg1 = *argp1;
61710   {
61711     try {
61712       result = Dali::Toolkit::Alignment::DownCast(arg1);
61713     } catch (std::out_of_range& e) {
61714       {
61715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61716       };
61717     } catch (std::exception& e) {
61718       {
61719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61720       };
61721     } catch (...) {
61722       {
61723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61724       };
61725     }
61726   }
61727   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61728   return jresult;
61729 }
61730
61731
61732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
61733   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61734   Dali::Toolkit::Alignment::Type arg2 ;
61735
61736   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61737   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
61738   {
61739     try {
61740       (arg1)->SetAlignmentType(arg2);
61741     } catch (std::out_of_range& e) {
61742       {
61743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61744       };
61745     } catch (std::exception& e) {
61746       {
61747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61748       };
61749     } catch (...) {
61750       {
61751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61752       };
61753     }
61754   }
61755 }
61756
61757
61758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
61759   int jresult ;
61760   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61761   Dali::Toolkit::Alignment::Type result;
61762
61763   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61764   {
61765     try {
61766       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
61767     } catch (std::out_of_range& e) {
61768       {
61769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61770       };
61771     } catch (std::exception& e) {
61772       {
61773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61774       };
61775     } catch (...) {
61776       {
61777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61778       };
61779     }
61780   }
61781   jresult = (int)result;
61782   return jresult;
61783 }
61784
61785
61786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
61787   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61788   Dali::Toolkit::Alignment::Scaling arg2 ;
61789
61790   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61791   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
61792   {
61793     try {
61794       (arg1)->SetScaling(arg2);
61795     } catch (std::out_of_range& e) {
61796       {
61797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61798       };
61799     } catch (std::exception& e) {
61800       {
61801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61802       };
61803     } catch (...) {
61804       {
61805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61806       };
61807     }
61808   }
61809 }
61810
61811
61812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
61813   int jresult ;
61814   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61815   Dali::Toolkit::Alignment::Scaling result;
61816
61817   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61818   {
61819     try {
61820       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
61821     } catch (std::out_of_range& e) {
61822       {
61823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61824       };
61825     } catch (std::exception& e) {
61826       {
61827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61828       };
61829     } catch (...) {
61830       {
61831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61832       };
61833     }
61834   }
61835   jresult = (int)result;
61836   return jresult;
61837 }
61838
61839
61840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
61841   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61842   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
61843
61844   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61845   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
61846   if (!arg2) {
61847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
61848     return ;
61849   }
61850   {
61851     try {
61852       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
61853     } catch (std::out_of_range& e) {
61854       {
61855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61856       };
61857     } catch (std::exception& e) {
61858       {
61859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61860       };
61861     } catch (...) {
61862       {
61863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61864       };
61865     }
61866   }
61867 }
61868
61869
61870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
61871   void * jresult ;
61872   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61873   Dali::Toolkit::Alignment::Padding *result = 0 ;
61874
61875   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61876   {
61877     try {
61878       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
61879     } catch (std::out_of_range& e) {
61880       {
61881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61882       };
61883     } catch (std::exception& e) {
61884       {
61885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61886       };
61887     } catch (...) {
61888       {
61889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61890       };
61891     }
61892   }
61893   jresult = (void *)result;
61894   return jresult;
61895 }
61896
61897
61898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
61899   void * jresult ;
61900   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61901   Dali::Toolkit::Alignment *arg2 = 0 ;
61902   Dali::Toolkit::Alignment *result = 0 ;
61903
61904   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61905   arg2 = (Dali::Toolkit::Alignment *)jarg2;
61906   if (!arg2) {
61907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
61908     return 0;
61909   }
61910   {
61911     try {
61912       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
61913     } catch (std::out_of_range& e) {
61914       {
61915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61916       };
61917     } catch (std::exception& e) {
61918       {
61919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61920       };
61921     } catch (...) {
61922       {
61923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61924       };
61925     }
61926   }
61927   jresult = (void *)result;
61928   return jresult;
61929 }
61930
61931
61932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
61933   int jresult ;
61934   int result;
61935
61936   result = (int)Dali::Toolkit::Button::Property::DISABLED;
61937   jresult = (int)result;
61938   return jresult;
61939 }
61940
61941
61942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
61943   int jresult ;
61944   int result;
61945
61946   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
61947   jresult = (int)result;
61948   return jresult;
61949 }
61950
61951
61952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
61953   int jresult ;
61954   int result;
61955
61956   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
61957   jresult = (int)result;
61958   return jresult;
61959 }
61960
61961
61962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
61963   int jresult ;
61964   int result;
61965
61966   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
61967   jresult = (int)result;
61968   return jresult;
61969 }
61970
61971
61972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
61973   int jresult ;
61974   int result;
61975
61976   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
61977   jresult = (int)result;
61978   return jresult;
61979 }
61980
61981
61982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
61983   int jresult ;
61984   int result;
61985
61986   result = (int)Dali::Toolkit::Button::Property::SELECTED;
61987   jresult = (int)result;
61988   return jresult;
61989 }
61990
61991
61992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
61993   int jresult ;
61994   int result;
61995
61996   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
61997   jresult = (int)result;
61998   return jresult;
61999 }
62000
62001
62002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
62003   int jresult ;
62004   int result;
62005
62006   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
62007   jresult = (int)result;
62008   return jresult;
62009 }
62010
62011
62012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
62013   int jresult ;
62014   int result;
62015
62016   result = (int)Dali::Toolkit::Button::Property::LABEL;
62017   jresult = (int)result;
62018   return jresult;
62019 }
62020
62021
62022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
62023   int jresult ;
62024   int result;
62025
62026   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
62027   jresult = (int)result;
62028   return jresult;
62029 }
62030
62031
62032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
62033   void * jresult ;
62034   Dali::Toolkit::Button::Property *result = 0 ;
62035
62036   {
62037     try {
62038       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
62039     } catch (std::out_of_range& e) {
62040       {
62041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62042       };
62043     } catch (std::exception& e) {
62044       {
62045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62046       };
62047     } catch (...) {
62048       {
62049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62050       };
62051     }
62052   }
62053   jresult = (void *)result;
62054   return jresult;
62055 }
62056
62057
62058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
62059   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
62060
62061   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
62062   {
62063     try {
62064       delete arg1;
62065     } catch (std::out_of_range& e) {
62066       {
62067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62068       };
62069     } catch (std::exception& e) {
62070       {
62071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62072       };
62073     } catch (...) {
62074       {
62075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62076       };
62077     }
62078   }
62079 }
62080
62081
62082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
62083   void * jresult ;
62084   Dali::Toolkit::Button *result = 0 ;
62085
62086   {
62087     try {
62088       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
62089     } catch (std::out_of_range& e) {
62090       {
62091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62092       };
62093     } catch (std::exception& e) {
62094       {
62095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62096       };
62097     } catch (...) {
62098       {
62099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62100       };
62101     }
62102   }
62103   jresult = (void *)result;
62104   return jresult;
62105 }
62106
62107
62108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
62109   void * jresult ;
62110   Dali::Toolkit::Button *arg1 = 0 ;
62111   Dali::Toolkit::Button *result = 0 ;
62112
62113   arg1 = (Dali::Toolkit::Button *)jarg1;
62114   if (!arg1) {
62115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
62116     return 0;
62117   }
62118   {
62119     try {
62120       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
62121     } catch (std::out_of_range& e) {
62122       {
62123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62124       };
62125     } catch (std::exception& e) {
62126       {
62127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62128       };
62129     } catch (...) {
62130       {
62131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62132       };
62133     }
62134   }
62135   jresult = (void *)result;
62136   return jresult;
62137 }
62138
62139
62140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
62141   void * jresult ;
62142   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62143   Dali::Toolkit::Button *arg2 = 0 ;
62144   Dali::Toolkit::Button *result = 0 ;
62145
62146   arg1 = (Dali::Toolkit::Button *)jarg1;
62147   arg2 = (Dali::Toolkit::Button *)jarg2;
62148   if (!arg2) {
62149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
62150     return 0;
62151   }
62152   {
62153     try {
62154       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
62155     } catch (std::out_of_range& e) {
62156       {
62157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62158       };
62159     } catch (std::exception& e) {
62160       {
62161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62162       };
62163     } catch (...) {
62164       {
62165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62166       };
62167     }
62168   }
62169   jresult = (void *)result;
62170   return jresult;
62171 }
62172
62173
62174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
62175   void * jresult ;
62176   Dali::BaseHandle arg1 ;
62177   Dali::BaseHandle *argp1 ;
62178   Dali::Toolkit::Button result;
62179
62180   argp1 = (Dali::BaseHandle *)jarg1;
62181   if (!argp1) {
62182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62183     return 0;
62184   }
62185   arg1 = *argp1;
62186   {
62187     try {
62188       result = Dali::Toolkit::Button::DownCast(arg1);
62189     } catch (std::out_of_range& e) {
62190       {
62191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62192       };
62193     } catch (std::exception& e) {
62194       {
62195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62196       };
62197     } catch (...) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62200       };
62201     }
62202   }
62203   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
62204   return jresult;
62205 }
62206
62207
62208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
62209   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62210
62211   arg1 = (Dali::Toolkit::Button *)jarg1;
62212   {
62213     try {
62214       delete arg1;
62215     } catch (std::out_of_range& e) {
62216       {
62217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62218       };
62219     } catch (std::exception& e) {
62220       {
62221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62222       };
62223     } catch (...) {
62224       {
62225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62226       };
62227     }
62228   }
62229 }
62230
62231
62232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
62233   unsigned int jresult ;
62234   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62235   bool result;
62236
62237   arg1 = (Dali::Toolkit::Button *)jarg1;
62238   {
62239     try {
62240       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
62241     } catch (std::out_of_range& e) {
62242       {
62243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62244       };
62245     } catch (std::exception& e) {
62246       {
62247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62248       };
62249     } catch (...) {
62250       {
62251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62252       };
62253     }
62254   }
62255   jresult = result;
62256   return jresult;
62257 }
62258
62259
62260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
62261   unsigned int jresult ;
62262   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62263   bool result;
62264
62265   arg1 = (Dali::Toolkit::Button *)jarg1;
62266   {
62267     try {
62268       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
62269     } catch (std::out_of_range& e) {
62270       {
62271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62272       };
62273     } catch (std::exception& e) {
62274       {
62275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62276       };
62277     } catch (...) {
62278       {
62279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62280       };
62281     }
62282   }
62283   jresult = result;
62284   return jresult;
62285 }
62286
62287
62288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
62289   float jresult ;
62290   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62291   float result;
62292
62293   arg1 = (Dali::Toolkit::Button *)jarg1;
62294   {
62295     try {
62296       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
62297     } catch (std::out_of_range& e) {
62298       {
62299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62300       };
62301     } catch (std::exception& e) {
62302       {
62303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62304       };
62305     } catch (...) {
62306       {
62307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62308       };
62309     }
62310   }
62311   jresult = result;
62312   return jresult;
62313 }
62314
62315
62316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
62317   float jresult ;
62318   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62319   float result;
62320
62321   arg1 = (Dali::Toolkit::Button *)jarg1;
62322   {
62323     try {
62324       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
62325     } catch (std::out_of_range& e) {
62326       {
62327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62328       };
62329     } catch (std::exception& e) {
62330       {
62331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62332       };
62333     } catch (...) {
62334       {
62335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62336       };
62337     }
62338   }
62339   jresult = result;
62340   return jresult;
62341 }
62342
62343
62344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
62345   unsigned int jresult ;
62346   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62347   bool result;
62348
62349   arg1 = (Dali::Toolkit::Button *)jarg1;
62350   {
62351     try {
62352       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
62353     } catch (std::out_of_range& e) {
62354       {
62355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62356       };
62357     } catch (std::exception& e) {
62358       {
62359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62360       };
62361     } catch (...) {
62362       {
62363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62364       };
62365     }
62366   }
62367   jresult = result;
62368   return jresult;
62369 }
62370
62371
62372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
62373   unsigned int jresult ;
62374   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62375   bool result;
62376
62377   arg1 = (Dali::Toolkit::Button *)jarg1;
62378   {
62379     try {
62380       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
62381     } catch (std::out_of_range& e) {
62382       {
62383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62384       };
62385     } catch (std::exception& e) {
62386       {
62387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62388       };
62389     } catch (...) {
62390       {
62391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62392       };
62393     }
62394   }
62395   jresult = result;
62396   return jresult;
62397 }
62398
62399
62400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
62401   float jresult ;
62402   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62403   float result;
62404
62405   arg1 = (Dali::Toolkit::Button *)jarg1;
62406   {
62407     try {
62408       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
62409     } catch (std::out_of_range& e) {
62410       {
62411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62412       };
62413     } catch (std::exception& e) {
62414       {
62415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62416       };
62417     } catch (...) {
62418       {
62419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62420       };
62421     }
62422   }
62423   jresult = result;
62424   return jresult;
62425 }
62426
62427
62428 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
62429   char * jresult ;
62430   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62431   std::string result;
62432
62433   arg1 = (Dali::Toolkit::Button *)jarg1;
62434   {
62435     try {
62436       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
62437     } catch (std::out_of_range& e) {
62438       {
62439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62440       };
62441     } catch (std::exception& e) {
62442       {
62443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62444       };
62445     } catch (...) {
62446       {
62447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62448       };
62449     }
62450   }
62451   jresult = SWIG_csharp_string_callback((&result)->c_str());
62452   return jresult;
62453 }
62454
62455
62456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
62457   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62458   Dali::Actor arg2 ;
62459   Dali::Actor *argp2 ;
62460
62461   arg1 = (Dali::Toolkit::Button *)jarg1;
62462   argp2 = (Dali::Actor *)jarg2;
62463   if (!argp2) {
62464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62465     return ;
62466   }
62467   arg2 = *argp2;
62468   {
62469     try {
62470       (arg1)->SetLabel(arg2);
62471     } catch (std::out_of_range& e) {
62472       {
62473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62474       };
62475     } catch (std::exception& e) {
62476       {
62477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62478       };
62479     } catch (...) {
62480       {
62481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62482       };
62483     }
62484   }
62485 }
62486
62487
62488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
62489   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62490   Dali::Image arg2 ;
62491   Dali::Image *argp2 ;
62492
62493   arg1 = (Dali::Toolkit::Button *)jarg1;
62494   argp2 = (Dali::Image *)jarg2;
62495   if (!argp2) {
62496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62497     return ;
62498   }
62499   arg2 = *argp2;
62500   {
62501     try {
62502       (arg1)->SetButtonImage(arg2);
62503     } catch (std::out_of_range& e) {
62504       {
62505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62506       };
62507     } catch (std::exception& e) {
62508       {
62509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62510       };
62511     } catch (...) {
62512       {
62513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62514       };
62515     }
62516   }
62517 }
62518
62519
62520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
62521   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62522   Dali::Image arg2 ;
62523   Dali::Image *argp2 ;
62524
62525   arg1 = (Dali::Toolkit::Button *)jarg1;
62526   argp2 = (Dali::Image *)jarg2;
62527   if (!argp2) {
62528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62529     return ;
62530   }
62531   arg2 = *argp2;
62532   {
62533     try {
62534       (arg1)->SetSelectedImage(arg2);
62535     } catch (std::out_of_range& e) {
62536       {
62537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62538       };
62539     } catch (std::exception& e) {
62540       {
62541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62542       };
62543     } catch (...) {
62544       {
62545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62546       };
62547     }
62548   }
62549 }
62550
62551
62552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
62553   void * jresult ;
62554   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62555   Dali::Actor result;
62556
62557   arg1 = (Dali::Toolkit::Button *)jarg1;
62558   {
62559     try {
62560       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62572       };
62573     }
62574   }
62575   jresult = new Dali::Actor((const Dali::Actor &)result);
62576   return jresult;
62577 }
62578
62579
62580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
62581   void * jresult ;
62582   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62583   Dali::Actor result;
62584
62585   arg1 = (Dali::Toolkit::Button *)jarg1;
62586   {
62587     try {
62588       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
62589     } catch (std::out_of_range& e) {
62590       {
62591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62592       };
62593     } catch (std::exception& e) {
62594       {
62595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62596       };
62597     } catch (...) {
62598       {
62599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62600       };
62601     }
62602   }
62603   jresult = new Dali::Actor((const Dali::Actor &)result);
62604   return jresult;
62605 }
62606
62607
62608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
62609   void * jresult ;
62610   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62611   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62612
62613   arg1 = (Dali::Toolkit::Button *)jarg1;
62614   {
62615     try {
62616       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
62617     } catch (std::out_of_range& e) {
62618       {
62619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62620       };
62621     } catch (std::exception& e) {
62622       {
62623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62624       };
62625     } catch (...) {
62626       {
62627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62628       };
62629     }
62630   }
62631   jresult = (void *)result;
62632   return jresult;
62633 }
62634
62635
62636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
62637   void * jresult ;
62638   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62639   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62640
62641   arg1 = (Dali::Toolkit::Button *)jarg1;
62642   {
62643     try {
62644       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
62645     } catch (std::out_of_range& e) {
62646       {
62647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62648       };
62649     } catch (std::exception& e) {
62650       {
62651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62652       };
62653     } catch (...) {
62654       {
62655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62656       };
62657     }
62658   }
62659   jresult = (void *)result;
62660   return jresult;
62661 }
62662
62663
62664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
62665   void * jresult ;
62666   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62667   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62668
62669   arg1 = (Dali::Toolkit::Button *)jarg1;
62670   {
62671     try {
62672       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
62673     } catch (std::out_of_range& e) {
62674       {
62675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62676       };
62677     } catch (std::exception& e) {
62678       {
62679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62680       };
62681     } catch (...) {
62682       {
62683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62684       };
62685     }
62686   }
62687   jresult = (void *)result;
62688   return jresult;
62689 }
62690
62691
62692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
62693   void * jresult ;
62694   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62695   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62696
62697   arg1 = (Dali::Toolkit::Button *)jarg1;
62698   {
62699     try {
62700       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
62701     } catch (std::out_of_range& e) {
62702       {
62703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62704       };
62705     } catch (std::exception& e) {
62706       {
62707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62708       };
62709     } catch (...) {
62710       {
62711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62712       };
62713     }
62714   }
62715   jresult = (void *)result;
62716   return jresult;
62717 }
62718
62719
62720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
62721   void * jresult ;
62722   Dali::Toolkit::CheckBoxButton *result = 0 ;
62723
62724   {
62725     try {
62726       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
62727     } catch (std::out_of_range& e) {
62728       {
62729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62730       };
62731     } catch (std::exception& e) {
62732       {
62733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62734       };
62735     } catch (...) {
62736       {
62737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62738       };
62739     }
62740   }
62741   jresult = (void *)result;
62742   return jresult;
62743 }
62744
62745
62746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
62747   void * jresult ;
62748   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
62749   Dali::Toolkit::CheckBoxButton *result = 0 ;
62750
62751   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62752   if (!arg1) {
62753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
62754     return 0;
62755   }
62756   {
62757     try {
62758       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
62759     } catch (std::out_of_range& e) {
62760       {
62761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62762       };
62763     } catch (std::exception& e) {
62764       {
62765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62766       };
62767     } catch (...) {
62768       {
62769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62770       };
62771     }
62772   }
62773   jresult = (void *)result;
62774   return jresult;
62775 }
62776
62777
62778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
62779   void * jresult ;
62780   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
62781   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
62782   Dali::Toolkit::CheckBoxButton *result = 0 ;
62783
62784   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62785   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
62786   if (!arg2) {
62787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
62788     return 0;
62789   }
62790   {
62791     try {
62792       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
62793     } catch (std::out_of_range& e) {
62794       {
62795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62796       };
62797     } catch (std::exception& e) {
62798       {
62799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62800       };
62801     } catch (...) {
62802       {
62803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62804       };
62805     }
62806   }
62807   jresult = (void *)result;
62808   return jresult;
62809 }
62810
62811
62812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
62813   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
62814
62815   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62816   {
62817     try {
62818       delete arg1;
62819     } catch (std::out_of_range& e) {
62820       {
62821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62822       };
62823     } catch (std::exception& e) {
62824       {
62825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62826       };
62827     } catch (...) {
62828       {
62829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62830       };
62831     }
62832   }
62833 }
62834
62835
62836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
62837   void * jresult ;
62838   Dali::Toolkit::CheckBoxButton result;
62839
62840   {
62841     try {
62842       result = Dali::Toolkit::CheckBoxButton::New();
62843     } catch (std::out_of_range& e) {
62844       {
62845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62846       };
62847     } catch (std::exception& e) {
62848       {
62849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62850       };
62851     } catch (...) {
62852       {
62853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62854       };
62855     }
62856   }
62857   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
62858   return jresult;
62859 }
62860
62861
62862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
62863   void * jresult ;
62864   Dali::BaseHandle arg1 ;
62865   Dali::BaseHandle *argp1 ;
62866   Dali::Toolkit::CheckBoxButton result;
62867
62868   argp1 = (Dali::BaseHandle *)jarg1;
62869   if (!argp1) {
62870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62871     return 0;
62872   }
62873   arg1 = *argp1;
62874   {
62875     try {
62876       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
62877     } catch (std::out_of_range& e) {
62878       {
62879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62880       };
62881     } catch (std::exception& e) {
62882       {
62883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62884       };
62885     } catch (...) {
62886       {
62887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62888       };
62889     }
62890   }
62891   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
62892   return jresult;
62893 }
62894
62895
62896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
62897   int jresult ;
62898   int result;
62899
62900   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
62901   jresult = (int)result;
62902   return jresult;
62903 }
62904
62905
62906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
62907   int jresult ;
62908   int result;
62909
62910   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
62911   jresult = (int)result;
62912   return jresult;
62913 }
62914
62915
62916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
62917   int jresult ;
62918   int result;
62919
62920   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
62921   jresult = (int)result;
62922   return jresult;
62923 }
62924
62925
62926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
62927   int jresult ;
62928   int result;
62929
62930   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
62931   jresult = (int)result;
62932   return jresult;
62933 }
62934
62935
62936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
62937   int jresult ;
62938   int result;
62939
62940   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
62941   jresult = (int)result;
62942   return jresult;
62943 }
62944
62945
62946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
62947   void * jresult ;
62948   Dali::Toolkit::PushButton::Property *result = 0 ;
62949
62950   {
62951     try {
62952       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
62953     } catch (std::out_of_range& e) {
62954       {
62955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62956       };
62957     } catch (std::exception& e) {
62958       {
62959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62960       };
62961     } catch (...) {
62962       {
62963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62964       };
62965     }
62966   }
62967   jresult = (void *)result;
62968   return jresult;
62969 }
62970
62971
62972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
62973   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
62974
62975   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
62976   {
62977     try {
62978       delete arg1;
62979     } catch (std::out_of_range& e) {
62980       {
62981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62982       };
62983     } catch (std::exception& e) {
62984       {
62985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62986       };
62987     } catch (...) {
62988       {
62989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62990       };
62991     }
62992   }
62993 }
62994
62995
62996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
62997   void * jresult ;
62998   Dali::Toolkit::PushButton *result = 0 ;
62999
63000   {
63001     try {
63002       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
63003     } catch (std::out_of_range& e) {
63004       {
63005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63006       };
63007     } catch (std::exception& e) {
63008       {
63009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63010       };
63011     } catch (...) {
63012       {
63013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63014       };
63015     }
63016   }
63017   jresult = (void *)result;
63018   return jresult;
63019 }
63020
63021
63022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
63023   void * jresult ;
63024   Dali::Toolkit::PushButton *arg1 = 0 ;
63025   Dali::Toolkit::PushButton *result = 0 ;
63026
63027   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63028   if (!arg1) {
63029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
63030     return 0;
63031   }
63032   {
63033     try {
63034       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
63035     } catch (std::out_of_range& e) {
63036       {
63037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63038       };
63039     } catch (std::exception& e) {
63040       {
63041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63042       };
63043     } catch (...) {
63044       {
63045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63046       };
63047     }
63048   }
63049   jresult = (void *)result;
63050   return jresult;
63051 }
63052
63053
63054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
63055   void * jresult ;
63056   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63057   Dali::Toolkit::PushButton *arg2 = 0 ;
63058   Dali::Toolkit::PushButton *result = 0 ;
63059
63060   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63061   arg2 = (Dali::Toolkit::PushButton *)jarg2;
63062   if (!arg2) {
63063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
63064     return 0;
63065   }
63066   {
63067     try {
63068       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
63069     } catch (std::out_of_range& e) {
63070       {
63071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63072       };
63073     } catch (std::exception& e) {
63074       {
63075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63076       };
63077     } catch (...) {
63078       {
63079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63080       };
63081     }
63082   }
63083   jresult = (void *)result;
63084   return jresult;
63085 }
63086
63087
63088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
63089   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63090
63091   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63092   {
63093     try {
63094       delete arg1;
63095     } catch (std::out_of_range& e) {
63096       {
63097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63098       };
63099     } catch (std::exception& e) {
63100       {
63101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63102       };
63103     } catch (...) {
63104       {
63105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63106       };
63107     }
63108   }
63109 }
63110
63111
63112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
63113   void * jresult ;
63114   Dali::Toolkit::PushButton result;
63115
63116   {
63117     try {
63118       result = Dali::Toolkit::PushButton::New();
63119     } catch (std::out_of_range& e) {
63120       {
63121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63122       };
63123     } catch (std::exception& e) {
63124       {
63125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63126       };
63127     } catch (...) {
63128       {
63129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63130       };
63131     }
63132   }
63133   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
63134   return jresult;
63135 }
63136
63137
63138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
63139   void * jresult ;
63140   Dali::BaseHandle arg1 ;
63141   Dali::BaseHandle *argp1 ;
63142   Dali::Toolkit::PushButton result;
63143
63144   argp1 = (Dali::BaseHandle *)jarg1;
63145   if (!argp1) {
63146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63147     return 0;
63148   }
63149   arg1 = *argp1;
63150   {
63151     try {
63152       result = Dali::Toolkit::PushButton::DownCast(arg1);
63153     } catch (std::out_of_range& e) {
63154       {
63155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63156       };
63157     } catch (std::exception& e) {
63158       {
63159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63160       };
63161     } catch (...) {
63162       {
63163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63164       };
63165     }
63166   }
63167   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
63168   return jresult;
63169 }
63170
63171
63172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
63173   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63174   Dali::Image arg2 ;
63175   Dali::Image *argp2 ;
63176
63177   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63178   argp2 = (Dali::Image *)jarg2;
63179   if (!argp2) {
63180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63181     return ;
63182   }
63183   arg2 = *argp2;
63184   {
63185     try {
63186       (arg1)->SetButtonImage(arg2);
63187     } catch (std::out_of_range& e) {
63188       {
63189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63190       };
63191     } catch (std::exception& e) {
63192       {
63193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63194       };
63195     } catch (...) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63198       };
63199     }
63200   }
63201 }
63202
63203
63204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
63205   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63206   Dali::Actor arg2 ;
63207   Dali::Actor *argp2 ;
63208
63209   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63210   argp2 = (Dali::Actor *)jarg2;
63211   if (!argp2) {
63212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63213     return ;
63214   }
63215   arg2 = *argp2;
63216   {
63217     try {
63218       (arg1)->SetButtonImage(arg2);
63219     } catch (std::out_of_range& e) {
63220       {
63221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63222       };
63223     } catch (std::exception& e) {
63224       {
63225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63226       };
63227     } catch (...) {
63228       {
63229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63230       };
63231     }
63232   }
63233 }
63234
63235
63236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
63237   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63238   Dali::Actor arg2 ;
63239   Dali::Actor *argp2 ;
63240
63241   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63242   argp2 = (Dali::Actor *)jarg2;
63243   if (!argp2) {
63244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63245     return ;
63246   }
63247   arg2 = *argp2;
63248   {
63249     try {
63250       (arg1)->SetBackgroundImage(arg2);
63251     } catch (std::out_of_range& e) {
63252       {
63253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63254       };
63255     } catch (std::exception& e) {
63256       {
63257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63258       };
63259     } catch (...) {
63260       {
63261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63262       };
63263     }
63264   }
63265 }
63266
63267
63268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
63269   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63270   Dali::Image arg2 ;
63271   Dali::Image *argp2 ;
63272
63273   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63274   argp2 = (Dali::Image *)jarg2;
63275   if (!argp2) {
63276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63277     return ;
63278   }
63279   arg2 = *argp2;
63280   {
63281     try {
63282       (arg1)->SetSelectedImage(arg2);
63283     } catch (std::out_of_range& e) {
63284       {
63285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63286       };
63287     } catch (std::exception& e) {
63288       {
63289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63290       };
63291     } catch (...) {
63292       {
63293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63294       };
63295     }
63296   }
63297 }
63298
63299
63300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
63301   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63302   Dali::Actor arg2 ;
63303   Dali::Actor *argp2 ;
63304
63305   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63306   argp2 = (Dali::Actor *)jarg2;
63307   if (!argp2) {
63308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63309     return ;
63310   }
63311   arg2 = *argp2;
63312   {
63313     try {
63314       (arg1)->SetSelectedImage(arg2);
63315     } catch (std::out_of_range& e) {
63316       {
63317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63318       };
63319     } catch (std::exception& e) {
63320       {
63321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63322       };
63323     } catch (...) {
63324       {
63325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63326       };
63327     }
63328   }
63329 }
63330
63331
63332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
63333   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63334   Dali::Actor arg2 ;
63335   Dali::Actor *argp2 ;
63336
63337   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63338   argp2 = (Dali::Actor *)jarg2;
63339   if (!argp2) {
63340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63341     return ;
63342   }
63343   arg2 = *argp2;
63344   {
63345     try {
63346       (arg1)->SetSelectedBackgroundImage(arg2);
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63354       };
63355     } catch (...) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63358       };
63359     }
63360   }
63361 }
63362
63363
63364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
63365   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63366   Dali::Actor arg2 ;
63367   Dali::Actor *argp2 ;
63368
63369   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63370   argp2 = (Dali::Actor *)jarg2;
63371   if (!argp2) {
63372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63373     return ;
63374   }
63375   arg2 = *argp2;
63376   {
63377     try {
63378       (arg1)->SetDisabledBackgroundImage(arg2);
63379     } catch (std::out_of_range& e) {
63380       {
63381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63382       };
63383     } catch (std::exception& e) {
63384       {
63385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63386       };
63387     } catch (...) {
63388       {
63389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63390       };
63391     }
63392   }
63393 }
63394
63395
63396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
63397   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63398   Dali::Actor arg2 ;
63399   Dali::Actor *argp2 ;
63400
63401   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63402   argp2 = (Dali::Actor *)jarg2;
63403   if (!argp2) {
63404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63405     return ;
63406   }
63407   arg2 = *argp2;
63408   {
63409     try {
63410       (arg1)->SetDisabledImage(arg2);
63411     } catch (std::out_of_range& e) {
63412       {
63413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63414       };
63415     } catch (std::exception& e) {
63416       {
63417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63418       };
63419     } catch (...) {
63420       {
63421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63422       };
63423     }
63424   }
63425 }
63426
63427
63428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
63429   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63430   Dali::Actor arg2 ;
63431   Dali::Actor *argp2 ;
63432
63433   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63434   argp2 = (Dali::Actor *)jarg2;
63435   if (!argp2) {
63436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63437     return ;
63438   }
63439   arg2 = *argp2;
63440   {
63441     try {
63442       (arg1)->SetDisabledSelectedImage(arg2);
63443     } catch (std::out_of_range& e) {
63444       {
63445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63446       };
63447     } catch (std::exception& e) {
63448       {
63449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63450       };
63451     } catch (...) {
63452       {
63453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63454       };
63455     }
63456   }
63457 }
63458
63459
63460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
63461   void * jresult ;
63462   Dali::Toolkit::RadioButton *result = 0 ;
63463
63464   {
63465     try {
63466       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
63467     } catch (std::out_of_range& e) {
63468       {
63469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63470       };
63471     } catch (std::exception& e) {
63472       {
63473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63474       };
63475     } catch (...) {
63476       {
63477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63478       };
63479     }
63480   }
63481   jresult = (void *)result;
63482   return jresult;
63483 }
63484
63485
63486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
63487   void * jresult ;
63488   Dali::Toolkit::RadioButton *arg1 = 0 ;
63489   Dali::Toolkit::RadioButton *result = 0 ;
63490
63491   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63492   if (!arg1) {
63493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
63494     return 0;
63495   }
63496   {
63497     try {
63498       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
63499     } catch (std::out_of_range& e) {
63500       {
63501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63502       };
63503     } catch (std::exception& e) {
63504       {
63505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63506       };
63507     } catch (...) {
63508       {
63509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63510       };
63511     }
63512   }
63513   jresult = (void *)result;
63514   return jresult;
63515 }
63516
63517
63518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
63519   void * jresult ;
63520   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
63521   Dali::Toolkit::RadioButton *arg2 = 0 ;
63522   Dali::Toolkit::RadioButton *result = 0 ;
63523
63524   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63525   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
63526   if (!arg2) {
63527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
63528     return 0;
63529   }
63530   {
63531     try {
63532       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
63533     } catch (std::out_of_range& e) {
63534       {
63535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63536       };
63537     } catch (std::exception& e) {
63538       {
63539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63540       };
63541     } catch (...) {
63542       {
63543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63544       };
63545     }
63546   }
63547   jresult = (void *)result;
63548   return jresult;
63549 }
63550
63551
63552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
63553   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
63554
63555   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63556   {
63557     try {
63558       delete arg1;
63559     } catch (std::out_of_range& e) {
63560       {
63561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63562       };
63563     } catch (std::exception& e) {
63564       {
63565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63566       };
63567     } catch (...) {
63568       {
63569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63570       };
63571     }
63572   }
63573 }
63574
63575
63576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
63577   void * jresult ;
63578   Dali::Toolkit::RadioButton result;
63579
63580   {
63581     try {
63582       result = Dali::Toolkit::RadioButton::New();
63583     } catch (std::out_of_range& e) {
63584       {
63585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63586       };
63587     } catch (std::exception& e) {
63588       {
63589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63590       };
63591     } catch (...) {
63592       {
63593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63594       };
63595     }
63596   }
63597   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63598   return jresult;
63599 }
63600
63601
63602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
63603   void * jresult ;
63604   std::string *arg1 = 0 ;
63605   Dali::Toolkit::RadioButton result;
63606
63607   if (!jarg1) {
63608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63609     return 0;
63610   }
63611   std::string arg1_str(jarg1);
63612   arg1 = &arg1_str;
63613   {
63614     try {
63615       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
63616     } catch (std::out_of_range& e) {
63617       {
63618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63619       };
63620     } catch (std::exception& e) {
63621       {
63622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63623       };
63624     } catch (...) {
63625       {
63626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63627       };
63628     }
63629   }
63630   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63631
63632   //argout typemap for const std::string&
63633
63634   return jresult;
63635 }
63636
63637
63638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
63639   void * jresult ;
63640   Dali::BaseHandle arg1 ;
63641   Dali::BaseHandle *argp1 ;
63642   Dali::Toolkit::RadioButton result;
63643
63644   argp1 = (Dali::BaseHandle *)jarg1;
63645   if (!argp1) {
63646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63647     return 0;
63648   }
63649   arg1 = *argp1;
63650   {
63651     try {
63652       result = Dali::Toolkit::RadioButton::DownCast(arg1);
63653     } catch (std::out_of_range& e) {
63654       {
63655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63656       };
63657     } catch (std::exception& e) {
63658       {
63659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63660       };
63661     } catch (...) {
63662       {
63663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63664       };
63665     }
63666   }
63667   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63668   return jresult;
63669 }
63670
63671
63672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
63673   int jresult ;
63674   int result;
63675
63676   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
63677   jresult = (int)result;
63678   return jresult;
63679 }
63680
63681
63682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
63683   int jresult ;
63684   int result;
63685
63686   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
63687   jresult = (int)result;
63688   return jresult;
63689 }
63690
63691
63692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
63693   int jresult ;
63694   int result;
63695
63696   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
63697   jresult = (int)result;
63698   return jresult;
63699 }
63700
63701
63702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
63703   int jresult ;
63704   int result;
63705
63706   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
63707   jresult = (int)result;
63708   return jresult;
63709 }
63710
63711
63712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
63713   int jresult ;
63714   int result;
63715
63716   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
63717   jresult = (int)result;
63718   return jresult;
63719 }
63720
63721
63722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
63723   int jresult ;
63724   int result;
63725
63726   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
63727   jresult = (int)result;
63728   return jresult;
63729 }
63730
63731
63732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
63733   void * jresult ;
63734   Dali::Toolkit::FlexContainer::Property *result = 0 ;
63735
63736   {
63737     try {
63738       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
63739     } catch (std::out_of_range& e) {
63740       {
63741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63742       };
63743     } catch (std::exception& e) {
63744       {
63745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63746       };
63747     } catch (...) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63750       };
63751     }
63752   }
63753   jresult = (void *)result;
63754   return jresult;
63755 }
63756
63757
63758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
63759   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
63760
63761   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
63762   {
63763     try {
63764       delete arg1;
63765     } catch (std::out_of_range& e) {
63766       {
63767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63768       };
63769     } catch (std::exception& e) {
63770       {
63771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63772       };
63773     } catch (...) {
63774       {
63775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63776       };
63777     }
63778   }
63779 }
63780
63781
63782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
63783   int jresult ;
63784   int result;
63785
63786   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
63787   jresult = (int)result;
63788   return jresult;
63789 }
63790
63791
63792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
63793   int jresult ;
63794   int result;
63795
63796   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
63797   jresult = (int)result;
63798   return jresult;
63799 }
63800
63801
63802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
63803   int jresult ;
63804   int result;
63805
63806   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
63807   jresult = (int)result;
63808   return jresult;
63809 }
63810
63811
63812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
63813   void * jresult ;
63814   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
63815
63816   {
63817     try {
63818       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
63819     } catch (std::out_of_range& e) {
63820       {
63821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63822       };
63823     } catch (std::exception& e) {
63824       {
63825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63826       };
63827     } catch (...) {
63828       {
63829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63830       };
63831     }
63832   }
63833   jresult = (void *)result;
63834   return jresult;
63835 }
63836
63837
63838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
63839   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
63840
63841   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
63842   {
63843     try {
63844       delete arg1;
63845     } catch (std::out_of_range& e) {
63846       {
63847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63848       };
63849     } catch (std::exception& e) {
63850       {
63851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63852       };
63853     } catch (...) {
63854       {
63855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63856       };
63857     }
63858   }
63859 }
63860
63861
63862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
63863   void * jresult ;
63864   Dali::Toolkit::FlexContainer *result = 0 ;
63865
63866   {
63867     try {
63868       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
63869     } catch (std::out_of_range& e) {
63870       {
63871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63872       };
63873     } catch (std::exception& e) {
63874       {
63875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63876       };
63877     } catch (...) {
63878       {
63879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63880       };
63881     }
63882   }
63883   jresult = (void *)result;
63884   return jresult;
63885 }
63886
63887
63888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
63889   void * jresult ;
63890   Dali::Toolkit::FlexContainer *arg1 = 0 ;
63891   Dali::Toolkit::FlexContainer *result = 0 ;
63892
63893   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
63894   if (!arg1) {
63895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
63896     return 0;
63897   }
63898   {
63899     try {
63900       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
63901     } catch (std::out_of_range& e) {
63902       {
63903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63904       };
63905     } catch (std::exception& e) {
63906       {
63907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63908       };
63909     } catch (...) {
63910       {
63911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63912       };
63913     }
63914   }
63915   jresult = (void *)result;
63916   return jresult;
63917 }
63918
63919
63920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
63921   void * jresult ;
63922   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
63923   Dali::Toolkit::FlexContainer *arg2 = 0 ;
63924   Dali::Toolkit::FlexContainer *result = 0 ;
63925
63926   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
63927   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
63928   if (!arg2) {
63929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
63930     return 0;
63931   }
63932   {
63933     try {
63934       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
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 = (void *)result;
63950   return jresult;
63951 }
63952
63953
63954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
63955   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
63956
63957   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
63958   {
63959     try {
63960       delete arg1;
63961     } catch (std::out_of_range& e) {
63962       {
63963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63964       };
63965     } catch (std::exception& e) {
63966       {
63967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63968       };
63969     } catch (...) {
63970       {
63971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63972       };
63973     }
63974   }
63975 }
63976
63977
63978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
63979   void * jresult ;
63980   Dali::Toolkit::FlexContainer result;
63981
63982   {
63983     try {
63984       result = Dali::Toolkit::FlexContainer::New();
63985     } catch (std::out_of_range& e) {
63986       {
63987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63988       };
63989     } catch (std::exception& e) {
63990       {
63991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63992       };
63993     } catch (...) {
63994       {
63995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63996       };
63997     }
63998   }
63999   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
64000   return jresult;
64001 }
64002
64003
64004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
64005   void * jresult ;
64006   Dali::BaseHandle arg1 ;
64007   Dali::BaseHandle *argp1 ;
64008   Dali::Toolkit::FlexContainer result;
64009
64010   argp1 = (Dali::BaseHandle *)jarg1;
64011   if (!argp1) {
64012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64013     return 0;
64014   }
64015   arg1 = *argp1;
64016   {
64017     try {
64018       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
64019     } catch (std::out_of_range& e) {
64020       {
64021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64022       };
64023     } catch (std::exception& e) {
64024       {
64025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64026       };
64027     } catch (...) {
64028       {
64029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64030       };
64031     }
64032   }
64033   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
64034   return jresult;
64035 }
64036
64037
64038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
64039   int jresult ;
64040   int result;
64041
64042   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
64043   jresult = (int)result;
64044   return jresult;
64045 }
64046
64047
64048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
64049   int jresult ;
64050   int result;
64051
64052   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
64053   jresult = (int)result;
64054   return jresult;
64055 }
64056
64057
64058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
64059   int jresult ;
64060   int result;
64061
64062   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
64063   jresult = (int)result;
64064   return jresult;
64065 }
64066
64067
64068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
64069   int jresult ;
64070   int result;
64071
64072   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
64073   jresult = (int)result;
64074   return jresult;
64075 }
64076
64077
64078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
64079   void * jresult ;
64080   Dali::Toolkit::ImageView::Property *result = 0 ;
64081
64082   {
64083     try {
64084       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
64085     } catch (std::out_of_range& e) {
64086       {
64087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64088       };
64089     } catch (std::exception& e) {
64090       {
64091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64096       };
64097     }
64098   }
64099   jresult = (void *)result;
64100   return jresult;
64101 }
64102
64103
64104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
64105   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
64106
64107   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
64108   {
64109     try {
64110       delete arg1;
64111     } catch (std::out_of_range& e) {
64112       {
64113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64114       };
64115     } catch (std::exception& e) {
64116       {
64117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64118       };
64119     } catch (...) {
64120       {
64121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64122       };
64123     }
64124   }
64125 }
64126
64127
64128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
64129   void * jresult ;
64130   Dali::Toolkit::ImageView *result = 0 ;
64131
64132   {
64133     try {
64134       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
64135     } catch (std::out_of_range& e) {
64136       {
64137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64138       };
64139     } catch (std::exception& e) {
64140       {
64141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64142       };
64143     } catch (...) {
64144       {
64145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64146       };
64147     }
64148   }
64149   jresult = (void *)result;
64150   return jresult;
64151 }
64152
64153
64154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
64155   void * jresult ;
64156   Dali::Toolkit::ImageView result;
64157
64158   {
64159     try {
64160       result = Dali::Toolkit::ImageView::New();
64161     } catch (std::out_of_range& e) {
64162       {
64163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64164       };
64165     } catch (std::exception& e) {
64166       {
64167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64168       };
64169     } catch (...) {
64170       {
64171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64172       };
64173     }
64174   }
64175   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64176   return jresult;
64177 }
64178
64179
64180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
64181   void * jresult ;
64182   Dali::Image arg1 ;
64183   Dali::Image *argp1 ;
64184   Dali::Toolkit::ImageView result;
64185
64186   argp1 = (Dali::Image *)jarg1;
64187   if (!argp1) {
64188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64189     return 0;
64190   }
64191   arg1 = *argp1;
64192   {
64193     try {
64194       result = Dali::Toolkit::ImageView::New(arg1);
64195     } catch (std::out_of_range& e) {
64196       {
64197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64198       };
64199     } catch (std::exception& e) {
64200       {
64201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64202       };
64203     } catch (...) {
64204       {
64205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64206       };
64207     }
64208   }
64209   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64210   return jresult;
64211 }
64212
64213
64214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
64215   void * jresult ;
64216   std::string *arg1 = 0 ;
64217   Dali::Toolkit::ImageView result;
64218
64219   if (!jarg1) {
64220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64221     return 0;
64222   }
64223   std::string arg1_str(jarg1);
64224   arg1 = &arg1_str;
64225   {
64226     try {
64227       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
64228     } catch (std::out_of_range& e) {
64229       {
64230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64231       };
64232     } catch (std::exception& e) {
64233       {
64234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64235       };
64236     } catch (...) {
64237       {
64238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64239       };
64240     }
64241   }
64242   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64243
64244   //argout typemap for const std::string&
64245
64246   return jresult;
64247 }
64248
64249
64250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
64251   void * jresult ;
64252   std::string *arg1 = 0 ;
64253   Dali::ImageDimensions arg2 ;
64254   Dali::ImageDimensions *argp2 ;
64255   Dali::Toolkit::ImageView result;
64256
64257   if (!jarg1) {
64258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64259     return 0;
64260   }
64261   std::string arg1_str(jarg1);
64262   arg1 = &arg1_str;
64263   argp2 = (Dali::ImageDimensions *)jarg2;
64264   if (!argp2) {
64265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
64266     return 0;
64267   }
64268   arg2 = *argp2;
64269   {
64270     try {
64271       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
64272     } catch (std::out_of_range& e) {
64273       {
64274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64275       };
64276     } catch (std::exception& e) {
64277       {
64278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64279       };
64280     } catch (...) {
64281       {
64282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64283       };
64284     }
64285   }
64286   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64287
64288   //argout typemap for const std::string&
64289
64290   return jresult;
64291 }
64292
64293
64294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
64295   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64296
64297   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64298   {
64299     try {
64300       delete arg1;
64301     } catch (std::out_of_range& e) {
64302       {
64303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64304       };
64305     } catch (std::exception& e) {
64306       {
64307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64308       };
64309     } catch (...) {
64310       {
64311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64312       };
64313     }
64314   }
64315 }
64316
64317
64318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
64319   void * jresult ;
64320   Dali::Toolkit::ImageView *arg1 = 0 ;
64321   Dali::Toolkit::ImageView *result = 0 ;
64322
64323   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64324   if (!arg1) {
64325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
64326     return 0;
64327   }
64328   {
64329     try {
64330       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
64331     } catch (std::out_of_range& e) {
64332       {
64333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64334       };
64335     } catch (std::exception& e) {
64336       {
64337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64338       };
64339     } catch (...) {
64340       {
64341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64342       };
64343     }
64344   }
64345   jresult = (void *)result;
64346   return jresult;
64347 }
64348
64349
64350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
64351   void * jresult ;
64352   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64353   Dali::Toolkit::ImageView *arg2 = 0 ;
64354   Dali::Toolkit::ImageView *result = 0 ;
64355
64356   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64357   arg2 = (Dali::Toolkit::ImageView *)jarg2;
64358   if (!arg2) {
64359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
64360     return 0;
64361   }
64362   {
64363     try {
64364       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
64365     } catch (std::out_of_range& e) {
64366       {
64367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64368       };
64369     } catch (std::exception& e) {
64370       {
64371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64372       };
64373     } catch (...) {
64374       {
64375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64376       };
64377     }
64378   }
64379   jresult = (void *)result;
64380   return jresult;
64381 }
64382
64383
64384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
64385   void * jresult ;
64386   Dali::BaseHandle arg1 ;
64387   Dali::BaseHandle *argp1 ;
64388   Dali::Toolkit::ImageView result;
64389
64390   argp1 = (Dali::BaseHandle *)jarg1;
64391   if (!argp1) {
64392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64393     return 0;
64394   }
64395   arg1 = *argp1;
64396   {
64397     try {
64398       result = Dali::Toolkit::ImageView::DownCast(arg1);
64399     } catch (std::out_of_range& e) {
64400       {
64401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64402       };
64403     } catch (std::exception& e) {
64404       {
64405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64406       };
64407     } catch (...) {
64408       {
64409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64410       };
64411     }
64412   }
64413   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64414   return jresult;
64415 }
64416
64417
64418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
64419   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64420   Dali::Image arg2 ;
64421   Dali::Image *argp2 ;
64422
64423   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64424   argp2 = (Dali::Image *)jarg2;
64425   if (!argp2) {
64426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64427     return ;
64428   }
64429   arg2 = *argp2;
64430   {
64431     try {
64432       (arg1)->SetImage(arg2);
64433     } catch (std::out_of_range& e) {
64434       {
64435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64436       };
64437     } catch (std::exception& e) {
64438       {
64439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64440       };
64441     } catch (...) {
64442       {
64443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64444       };
64445     }
64446   }
64447 }
64448
64449
64450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
64451   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64452   std::string *arg2 = 0 ;
64453
64454   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64455   if (!jarg2) {
64456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64457     return ;
64458   }
64459   std::string arg2_str(jarg2);
64460   arg2 = &arg2_str;
64461   {
64462     try {
64463       (arg1)->SetImage((std::string const &)*arg2);
64464     } catch (std::out_of_range& e) {
64465       {
64466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64467       };
64468     } catch (std::exception& e) {
64469       {
64470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64471       };
64472     } catch (...) {
64473       {
64474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64475       };
64476     }
64477   }
64478
64479   //argout typemap for const std::string&
64480
64481 }
64482
64483
64484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
64485   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64486   std::string *arg2 = 0 ;
64487   Dali::ImageDimensions arg3 ;
64488   Dali::ImageDimensions *argp3 ;
64489
64490   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64491   if (!jarg2) {
64492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64493     return ;
64494   }
64495   std::string arg2_str(jarg2);
64496   arg2 = &arg2_str;
64497   argp3 = (Dali::ImageDimensions *)jarg3;
64498   if (!argp3) {
64499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
64500     return ;
64501   }
64502   arg3 = *argp3;
64503   {
64504     try {
64505       (arg1)->SetImage((std::string const &)*arg2,arg3);
64506     } catch (std::out_of_range& e) {
64507       {
64508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64509       };
64510     } catch (std::exception& e) {
64511       {
64512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64513       };
64514     } catch (...) {
64515       {
64516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64517       };
64518     }
64519   }
64520
64521   //argout typemap for const std::string&
64522
64523 }
64524
64525
64526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
64527   void * jresult ;
64528   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64529   Dali::Image result;
64530
64531   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64532   {
64533     try {
64534       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
64535     } catch (std::out_of_range& e) {
64536       {
64537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64538       };
64539     } catch (std::exception& e) {
64540       {
64541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64542       };
64543     } catch (...) {
64544       {
64545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64546       };
64547     }
64548   }
64549   jresult = new Dali::Image((const Dali::Image &)result);
64550   return jresult;
64551 }
64552
64553
64554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
64555   int jresult ;
64556   int result;
64557
64558   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
64559   jresult = (int)result;
64560   return jresult;
64561 }
64562
64563
64564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
64565   int jresult ;
64566   int result;
64567
64568   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
64569   jresult = (int)result;
64570   return jresult;
64571 }
64572
64573
64574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
64575   int jresult ;
64576   int result;
64577
64578   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
64579   jresult = (int)result;
64580   return jresult;
64581 }
64582
64583
64584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
64585   int jresult ;
64586   int result;
64587
64588   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
64589   jresult = (int)result;
64590   return jresult;
64591 }
64592
64593
64594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
64595   int jresult ;
64596   int result;
64597
64598   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
64599   jresult = (int)result;
64600   return jresult;
64601 }
64602
64603
64604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
64605   int jresult ;
64606   int result;
64607
64608   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
64609   jresult = (int)result;
64610   return jresult;
64611 }
64612
64613
64614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
64615   int jresult ;
64616   int result;
64617
64618   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
64619   jresult = (int)result;
64620   return jresult;
64621 }
64622
64623
64624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
64625   int jresult ;
64626   int result;
64627
64628   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
64629   jresult = (int)result;
64630   return jresult;
64631 }
64632
64633
64634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
64635   void * jresult ;
64636   Dali::Toolkit::Model3dView::Property *result = 0 ;
64637
64638   {
64639     try {
64640       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
64641     } catch (std::out_of_range& e) {
64642       {
64643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64644       };
64645     } catch (std::exception& e) {
64646       {
64647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64648       };
64649     } catch (...) {
64650       {
64651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64652       };
64653     }
64654   }
64655   jresult = (void *)result;
64656   return jresult;
64657 }
64658
64659
64660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
64661   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
64662
64663   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
64664   {
64665     try {
64666       delete arg1;
64667     } catch (std::out_of_range& e) {
64668       {
64669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64670       };
64671     } catch (std::exception& e) {
64672       {
64673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64674       };
64675     } catch (...) {
64676       {
64677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64678       };
64679     }
64680   }
64681 }
64682
64683
64684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
64685   void * jresult ;
64686   Dali::Toolkit::Model3dView result;
64687
64688   {
64689     try {
64690       result = Dali::Toolkit::Model3dView::New();
64691     } catch (std::out_of_range& e) {
64692       {
64693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64694       };
64695     } catch (std::exception& e) {
64696       {
64697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64698       };
64699     } catch (...) {
64700       {
64701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64702       };
64703     }
64704   }
64705   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
64706   return jresult;
64707 }
64708
64709
64710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
64711   void * jresult ;
64712   std::string *arg1 = 0 ;
64713   std::string *arg2 = 0 ;
64714   std::string *arg3 = 0 ;
64715   Dali::Toolkit::Model3dView result;
64716
64717   if (!jarg1) {
64718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64719     return 0;
64720   }
64721   std::string arg1_str(jarg1);
64722   arg1 = &arg1_str;
64723   if (!jarg2) {
64724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64725     return 0;
64726   }
64727   std::string arg2_str(jarg2);
64728   arg2 = &arg2_str;
64729   if (!jarg3) {
64730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64731     return 0;
64732   }
64733   std::string arg3_str(jarg3);
64734   arg3 = &arg3_str;
64735   {
64736     try {
64737       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
64738     } catch (std::out_of_range& e) {
64739       {
64740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64741       };
64742     } catch (std::exception& e) {
64743       {
64744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64745       };
64746     } catch (...) {
64747       {
64748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64749       };
64750     }
64751   }
64752   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
64753
64754   //argout typemap for const std::string&
64755
64756
64757   //argout typemap for const std::string&
64758
64759
64760   //argout typemap for const std::string&
64761
64762   return jresult;
64763 }
64764
64765
64766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
64767   void * jresult ;
64768   Dali::Toolkit::Model3dView *result = 0 ;
64769
64770   {
64771     try {
64772       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
64773     } catch (std::out_of_range& e) {
64774       {
64775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64776       };
64777     } catch (std::exception& e) {
64778       {
64779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64780       };
64781     } catch (...) {
64782       {
64783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64784       };
64785     }
64786   }
64787   jresult = (void *)result;
64788   return jresult;
64789 }
64790
64791
64792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
64793   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
64794
64795   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64796   {
64797     try {
64798       delete arg1;
64799     } catch (std::out_of_range& e) {
64800       {
64801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64802       };
64803     } catch (std::exception& e) {
64804       {
64805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64806       };
64807     } catch (...) {
64808       {
64809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64810       };
64811     }
64812   }
64813 }
64814
64815
64816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
64817   void * jresult ;
64818   Dali::Toolkit::Model3dView *arg1 = 0 ;
64819   Dali::Toolkit::Model3dView *result = 0 ;
64820
64821   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64822   if (!arg1) {
64823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
64824     return 0;
64825   }
64826   {
64827     try {
64828       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
64829     } catch (std::out_of_range& e) {
64830       {
64831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64832       };
64833     } catch (std::exception& e) {
64834       {
64835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64836       };
64837     } catch (...) {
64838       {
64839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64840       };
64841     }
64842   }
64843   jresult = (void *)result;
64844   return jresult;
64845 }
64846
64847
64848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
64849   void * jresult ;
64850   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
64851   Dali::Toolkit::Model3dView *arg2 = 0 ;
64852   Dali::Toolkit::Model3dView *result = 0 ;
64853
64854   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64855   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
64856   if (!arg2) {
64857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
64858     return 0;
64859   }
64860   {
64861     try {
64862       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
64863     } catch (std::out_of_range& e) {
64864       {
64865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64866       };
64867     } catch (std::exception& e) {
64868       {
64869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64870       };
64871     } catch (...) {
64872       {
64873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64874       };
64875     }
64876   }
64877   jresult = (void *)result;
64878   return jresult;
64879 }
64880
64881
64882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
64883   void * jresult ;
64884   Dali::BaseHandle arg1 ;
64885   Dali::BaseHandle *argp1 ;
64886   Dali::Toolkit::Model3dView result;
64887
64888   argp1 = (Dali::BaseHandle *)jarg1;
64889   if (!argp1) {
64890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64891     return 0;
64892   }
64893   arg1 = *argp1;
64894   {
64895     try {
64896       result = Dali::Toolkit::Model3dView::DownCast(arg1);
64897     } catch (std::out_of_range& e) {
64898       {
64899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64900       };
64901     } catch (std::exception& e) {
64902       {
64903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64904       };
64905     } catch (...) {
64906       {
64907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64908       };
64909     }
64910   }
64911   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
64912   return jresult;
64913 }
64914
64915
64916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
64917   int jresult ;
64918   int result;
64919
64920   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
64921   jresult = (int)result;
64922   return jresult;
64923 }
64924
64925
64926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
64927   int jresult ;
64928   int result;
64929
64930   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
64931   jresult = (int)result;
64932   return jresult;
64933 }
64934
64935
64936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
64937   int jresult ;
64938   int result;
64939
64940   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
64941   jresult = (int)result;
64942   return jresult;
64943 }
64944
64945
64946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
64947   int jresult ;
64948   int result;
64949
64950   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
64951   jresult = (int)result;
64952   return jresult;
64953 }
64954
64955
64956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
64957   int jresult ;
64958   int result;
64959
64960   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
64961   jresult = (int)result;
64962   return jresult;
64963 }
64964
64965
64966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
64967   int jresult ;
64968   int result;
64969
64970   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
64971   jresult = (int)result;
64972   return jresult;
64973 }
64974
64975
64976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
64977   int jresult ;
64978   int result;
64979
64980   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
64981   jresult = (int)result;
64982   return jresult;
64983 }
64984
64985
64986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
64987   int jresult ;
64988   int result;
64989
64990   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
64991   jresult = (int)result;
64992   return jresult;
64993 }
64994
64995
64996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
64997   int jresult ;
64998   int result;
64999
65000   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
65001   jresult = (int)result;
65002   return jresult;
65003 }
65004
65005
65006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
65007   void * jresult ;
65008   Dali::Toolkit::ScrollBar::Property *result = 0 ;
65009
65010   {
65011     try {
65012       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
65013     } catch (std::out_of_range& e) {
65014       {
65015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65016       };
65017     } catch (std::exception& e) {
65018       {
65019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65020       };
65021     } catch (...) {
65022       {
65023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65024       };
65025     }
65026   }
65027   jresult = (void *)result;
65028   return jresult;
65029 }
65030
65031
65032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
65033   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
65034
65035   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
65036   {
65037     try {
65038       delete arg1;
65039     } catch (std::out_of_range& e) {
65040       {
65041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65042       };
65043     } catch (std::exception& e) {
65044       {
65045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65046       };
65047     } catch (...) {
65048       {
65049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65050       };
65051     }
65052   }
65053 }
65054
65055
65056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
65057   void * jresult ;
65058   Dali::Toolkit::ScrollBar *result = 0 ;
65059
65060   {
65061     try {
65062       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
65063     } catch (std::out_of_range& e) {
65064       {
65065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65066       };
65067     } catch (std::exception& e) {
65068       {
65069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65070       };
65071     } catch (...) {
65072       {
65073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65074       };
65075     }
65076   }
65077   jresult = (void *)result;
65078   return jresult;
65079 }
65080
65081
65082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
65083   void * jresult ;
65084   Dali::Toolkit::ScrollBar *arg1 = 0 ;
65085   Dali::Toolkit::ScrollBar *result = 0 ;
65086
65087   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65088   if (!arg1) {
65089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
65090     return 0;
65091   }
65092   {
65093     try {
65094       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
65095     } catch (std::out_of_range& e) {
65096       {
65097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65098       };
65099     } catch (std::exception& e) {
65100       {
65101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65102       };
65103     } catch (...) {
65104       {
65105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65106       };
65107     }
65108   }
65109   jresult = (void *)result;
65110   return jresult;
65111 }
65112
65113
65114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
65115   void * jresult ;
65116   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65117   Dali::Toolkit::ScrollBar *arg2 = 0 ;
65118   Dali::Toolkit::ScrollBar *result = 0 ;
65119
65120   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65121   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
65122   if (!arg2) {
65123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
65124     return 0;
65125   }
65126   {
65127     try {
65128       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
65129     } catch (std::out_of_range& e) {
65130       {
65131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65132       };
65133     } catch (std::exception& e) {
65134       {
65135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65136       };
65137     } catch (...) {
65138       {
65139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65140       };
65141     }
65142   }
65143   jresult = (void *)result;
65144   return jresult;
65145 }
65146
65147
65148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
65149   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65150
65151   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65152   {
65153     try {
65154       delete arg1;
65155     } catch (std::out_of_range& e) {
65156       {
65157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65158       };
65159     } catch (std::exception& e) {
65160       {
65161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65162       };
65163     } catch (...) {
65164       {
65165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65166       };
65167     }
65168   }
65169 }
65170
65171
65172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
65173   void * jresult ;
65174   Dali::Toolkit::ScrollBar::Direction arg1 ;
65175   Dali::Toolkit::ScrollBar result;
65176
65177   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
65178   {
65179     try {
65180       result = Dali::Toolkit::ScrollBar::New(arg1);
65181     } catch (std::out_of_range& e) {
65182       {
65183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65184       };
65185     } catch (std::exception& e) {
65186       {
65187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65188       };
65189     } catch (...) {
65190       {
65191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65192       };
65193     }
65194   }
65195   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65196   return jresult;
65197 }
65198
65199
65200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
65201   void * jresult ;
65202   Dali::Toolkit::ScrollBar result;
65203
65204   {
65205     try {
65206       result = Dali::Toolkit::ScrollBar::New();
65207     } catch (std::out_of_range& e) {
65208       {
65209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65210       };
65211     } catch (std::exception& e) {
65212       {
65213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65214       };
65215     } catch (...) {
65216       {
65217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65218       };
65219     }
65220   }
65221   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65222   return jresult;
65223 }
65224
65225
65226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
65227   void * jresult ;
65228   Dali::BaseHandle arg1 ;
65229   Dali::BaseHandle *argp1 ;
65230   Dali::Toolkit::ScrollBar result;
65231
65232   argp1 = (Dali::BaseHandle *)jarg1;
65233   if (!argp1) {
65234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65235     return 0;
65236   }
65237   arg1 = *argp1;
65238   {
65239     try {
65240       result = Dali::Toolkit::ScrollBar::DownCast(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 = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65256   return jresult;
65257 }
65258
65259
65260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
65261   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65262   Dali::Handle arg2 ;
65263   Dali::Property::Index arg3 ;
65264   Dali::Property::Index arg4 ;
65265   Dali::Property::Index arg5 ;
65266   Dali::Property::Index arg6 ;
65267   Dali::Handle *argp2 ;
65268
65269   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65270   argp2 = (Dali::Handle *)jarg2;
65271   if (!argp2) {
65272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
65273     return ;
65274   }
65275   arg2 = *argp2;
65276   arg3 = (Dali::Property::Index)jarg3;
65277   arg4 = (Dali::Property::Index)jarg4;
65278   arg5 = (Dali::Property::Index)jarg5;
65279   arg6 = (Dali::Property::Index)jarg6;
65280   {
65281     try {
65282       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
65283     } catch (std::out_of_range& e) {
65284       {
65285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65286       };
65287     } catch (std::exception& e) {
65288       {
65289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65290       };
65291     } catch (...) {
65292       {
65293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65294       };
65295     }
65296   }
65297 }
65298
65299
65300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
65301   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65302   Dali::Actor arg2 ;
65303   Dali::Actor *argp2 ;
65304
65305   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65306   argp2 = (Dali::Actor *)jarg2;
65307   if (!argp2) {
65308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65309     return ;
65310   }
65311   arg2 = *argp2;
65312   {
65313     try {
65314       (arg1)->SetScrollIndicator(arg2);
65315     } catch (std::out_of_range& e) {
65316       {
65317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65318       };
65319     } catch (std::exception& e) {
65320       {
65321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65322       };
65323     } catch (...) {
65324       {
65325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65326       };
65327     }
65328   }
65329 }
65330
65331
65332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
65333   void * jresult ;
65334   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65335   Dali::Actor result;
65336
65337   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65338   {
65339     try {
65340       result = (arg1)->GetScrollIndicator();
65341     } catch (std::out_of_range& e) {
65342       {
65343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65344       };
65345     } catch (std::exception& e) {
65346       {
65347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65348       };
65349     } catch (...) {
65350       {
65351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65352       };
65353     }
65354   }
65355   jresult = new Dali::Actor((const Dali::Actor &)result);
65356   return jresult;
65357 }
65358
65359
65360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
65361   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65362   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
65363
65364   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65365   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
65366   if (!arg2) {
65367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
65368     return ;
65369   }
65370   {
65371     try {
65372       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
65373     } catch (std::out_of_range& e) {
65374       {
65375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65376       };
65377     } catch (std::exception& e) {
65378       {
65379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65380       };
65381     } catch (...) {
65382       {
65383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65384       };
65385     }
65386   }
65387 }
65388
65389
65390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
65391   void * jresult ;
65392   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65393   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
65394
65395   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65396   {
65397     try {
65398       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
65399     } catch (std::out_of_range& e) {
65400       {
65401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65402       };
65403     } catch (std::exception& e) {
65404       {
65405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65406       };
65407     } catch (...) {
65408       {
65409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65410       };
65411     }
65412   }
65413   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
65414   return jresult;
65415 }
65416
65417
65418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
65419   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65420   Dali::Toolkit::ScrollBar::Direction arg2 ;
65421
65422   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65423   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
65424   {
65425     try {
65426       (arg1)->SetScrollDirection(arg2);
65427     } catch (std::out_of_range& e) {
65428       {
65429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65430       };
65431     } catch (std::exception& e) {
65432       {
65433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65434       };
65435     } catch (...) {
65436       {
65437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65438       };
65439     }
65440   }
65441 }
65442
65443
65444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
65445   int jresult ;
65446   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65447   Dali::Toolkit::ScrollBar::Direction result;
65448
65449   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65450   {
65451     try {
65452       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
65453     } catch (std::out_of_range& e) {
65454       {
65455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65456       };
65457     } catch (std::exception& e) {
65458       {
65459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65460       };
65461     } catch (...) {
65462       {
65463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65464       };
65465     }
65466   }
65467   jresult = (int)result;
65468   return jresult;
65469 }
65470
65471
65472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
65473   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65474   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
65475
65476   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65477   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
65478   {
65479     try {
65480       (arg1)->SetIndicatorHeightPolicy(arg2);
65481     } catch (std::out_of_range& e) {
65482       {
65483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65484       };
65485     } catch (std::exception& e) {
65486       {
65487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65488       };
65489     } catch (...) {
65490       {
65491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65492       };
65493     }
65494   }
65495 }
65496
65497
65498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
65499   int jresult ;
65500   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65501   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
65502
65503   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65504   {
65505     try {
65506       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
65507     } catch (std::out_of_range& e) {
65508       {
65509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65510       };
65511     } catch (std::exception& e) {
65512       {
65513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65514       };
65515     } catch (...) {
65516       {
65517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65518       };
65519     }
65520   }
65521   jresult = (int)result;
65522   return jresult;
65523 }
65524
65525
65526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
65527   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65528   float arg2 ;
65529
65530   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65531   arg2 = (float)jarg2;
65532   {
65533     try {
65534       (arg1)->SetIndicatorFixedHeight(arg2);
65535     } catch (std::out_of_range& e) {
65536       {
65537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65538       };
65539     } catch (std::exception& e) {
65540       {
65541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65542       };
65543     } catch (...) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65546       };
65547     }
65548   }
65549 }
65550
65551
65552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
65553   float jresult ;
65554   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65555   float result;
65556
65557   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65558   {
65559     try {
65560       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
65561     } catch (std::out_of_range& e) {
65562       {
65563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65564       };
65565     } catch (std::exception& e) {
65566       {
65567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65568       };
65569     } catch (...) {
65570       {
65571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65572       };
65573     }
65574   }
65575   jresult = result;
65576   return jresult;
65577 }
65578
65579
65580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
65581   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65582   float arg2 ;
65583
65584   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65585   arg2 = (float)jarg2;
65586   {
65587     try {
65588       (arg1)->SetIndicatorShowDuration(arg2);
65589     } catch (std::out_of_range& e) {
65590       {
65591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65592       };
65593     } catch (std::exception& e) {
65594       {
65595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65596       };
65597     } catch (...) {
65598       {
65599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65600       };
65601     }
65602   }
65603 }
65604
65605
65606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
65607   float jresult ;
65608   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65609   float result;
65610
65611   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65612   {
65613     try {
65614       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
65615     } catch (std::out_of_range& e) {
65616       {
65617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65618       };
65619     } catch (std::exception& e) {
65620       {
65621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65622       };
65623     } catch (...) {
65624       {
65625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65626       };
65627     }
65628   }
65629   jresult = result;
65630   return jresult;
65631 }
65632
65633
65634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
65635   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65636   float arg2 ;
65637
65638   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65639   arg2 = (float)jarg2;
65640   {
65641     try {
65642       (arg1)->SetIndicatorHideDuration(arg2);
65643     } catch (std::out_of_range& e) {
65644       {
65645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65646       };
65647     } catch (std::exception& e) {
65648       {
65649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65650       };
65651     } catch (...) {
65652       {
65653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65654       };
65655     }
65656   }
65657 }
65658
65659
65660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
65661   float jresult ;
65662   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65663   float result;
65664
65665   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65666   {
65667     try {
65668       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
65669     } catch (std::out_of_range& e) {
65670       {
65671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65672       };
65673     } catch (std::exception& e) {
65674       {
65675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65676       };
65677     } catch (...) {
65678       {
65679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65680       };
65681     }
65682   }
65683   jresult = result;
65684   return jresult;
65685 }
65686
65687
65688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
65689   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65690
65691   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65692   {
65693     try {
65694       (arg1)->ShowIndicator();
65695     } catch (std::out_of_range& e) {
65696       {
65697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65698       };
65699     } catch (std::exception& e) {
65700       {
65701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65702       };
65703     } catch (...) {
65704       {
65705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65706       };
65707     }
65708   }
65709 }
65710
65711
65712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
65713   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65714
65715   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65716   {
65717     try {
65718       (arg1)->HideIndicator();
65719     } catch (std::out_of_range& e) {
65720       {
65721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65722       };
65723     } catch (std::exception& e) {
65724       {
65725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65726       };
65727     } catch (...) {
65728       {
65729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65730       };
65731     }
65732   }
65733 }
65734
65735
65736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
65737   void * jresult ;
65738   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65739   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
65740
65741   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65742   {
65743     try {
65744       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
65745     } catch (std::out_of_range& e) {
65746       {
65747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65748       };
65749     } catch (std::exception& e) {
65750       {
65751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65752       };
65753     } catch (...) {
65754       {
65755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65756       };
65757     }
65758   }
65759   jresult = (void *)result;
65760   return jresult;
65761 }
65762
65763
65764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
65765   void * jresult ;
65766   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65767   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
65768
65769   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65770   {
65771     try {
65772       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
65773     } catch (std::out_of_range& e) {
65774       {
65775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65776       };
65777     } catch (std::exception& e) {
65778       {
65779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (...) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65784       };
65785     }
65786   }
65787   jresult = (void *)result;
65788   return jresult;
65789 }
65790
65791
65792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
65793   int jresult ;
65794   int result;
65795
65796   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
65797   jresult = (int)result;
65798   return jresult;
65799 }
65800
65801
65802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
65803   int jresult ;
65804   int result;
65805
65806   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
65807   jresult = (int)result;
65808   return jresult;
65809 }
65810
65811
65812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
65813   int jresult ;
65814   int result;
65815
65816   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
65817   jresult = (int)result;
65818   return jresult;
65819 }
65820
65821
65822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
65823   int jresult ;
65824   int result;
65825
65826   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
65827   jresult = (int)result;
65828   return jresult;
65829 }
65830
65831
65832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
65833   int jresult ;
65834   int result;
65835
65836   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
65837   jresult = (int)result;
65838   return jresult;
65839 }
65840
65841
65842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
65843   int jresult ;
65844   int result;
65845
65846   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
65847   jresult = (int)result;
65848   return jresult;
65849 }
65850
65851
65852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
65853   int jresult ;
65854   int result;
65855
65856   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
65857   jresult = (int)result;
65858   return jresult;
65859 }
65860
65861
65862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
65863   int jresult ;
65864   int result;
65865
65866   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
65867   jresult = (int)result;
65868   return jresult;
65869 }
65870
65871
65872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
65873   int jresult ;
65874   int result;
65875
65876   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
65877   jresult = (int)result;
65878   return jresult;
65879 }
65880
65881
65882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
65883   int jresult ;
65884   int result;
65885
65886   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
65887   jresult = (int)result;
65888   return jresult;
65889 }
65890
65891
65892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
65893   int jresult ;
65894   int result;
65895
65896   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
65897   jresult = (int)result;
65898   return jresult;
65899 }
65900
65901
65902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
65903   int jresult ;
65904   int result;
65905
65906   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
65907   jresult = (int)result;
65908   return jresult;
65909 }
65910
65911
65912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
65913   int jresult ;
65914   int result;
65915
65916   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
65917   jresult = (int)result;
65918   return jresult;
65919 }
65920
65921
65922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
65923   int jresult ;
65924   int result;
65925
65926   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
65927   jresult = (int)result;
65928   return jresult;
65929 }
65930
65931
65932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
65933   void * jresult ;
65934   Dali::Toolkit::Scrollable::Property *result = 0 ;
65935
65936   {
65937     try {
65938       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
65939     } catch (std::out_of_range& e) {
65940       {
65941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65942       };
65943     } catch (std::exception& e) {
65944       {
65945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65946       };
65947     } catch (...) {
65948       {
65949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65950       };
65951     }
65952   }
65953   jresult = (void *)result;
65954   return jresult;
65955 }
65956
65957
65958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
65959   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
65960
65961   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
65962   {
65963     try {
65964       delete arg1;
65965     } catch (std::out_of_range& e) {
65966       {
65967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65968       };
65969     } catch (std::exception& e) {
65970       {
65971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65972       };
65973     } catch (...) {
65974       {
65975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65976       };
65977     }
65978   }
65979 }
65980
65981
65982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
65983   void * jresult ;
65984   Dali::Toolkit::Scrollable *result = 0 ;
65985
65986   {
65987     try {
65988       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
65989     } catch (std::out_of_range& e) {
65990       {
65991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65992       };
65993     } catch (std::exception& e) {
65994       {
65995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65996       };
65997     } catch (...) {
65998       {
65999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66000       };
66001     }
66002   }
66003   jresult = (void *)result;
66004   return jresult;
66005 }
66006
66007
66008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
66009   void * jresult ;
66010   Dali::Toolkit::Scrollable *arg1 = 0 ;
66011   Dali::Toolkit::Scrollable *result = 0 ;
66012
66013   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66014   if (!arg1) {
66015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
66016     return 0;
66017   }
66018   {
66019     try {
66020       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
66021     } catch (std::out_of_range& e) {
66022       {
66023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66024       };
66025     } catch (std::exception& e) {
66026       {
66027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66028       };
66029     } catch (...) {
66030       {
66031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66032       };
66033     }
66034   }
66035   jresult = (void *)result;
66036   return jresult;
66037 }
66038
66039
66040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
66041   void * jresult ;
66042   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66043   Dali::Toolkit::Scrollable *arg2 = 0 ;
66044   Dali::Toolkit::Scrollable *result = 0 ;
66045
66046   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66047   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
66048   if (!arg2) {
66049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
66050     return 0;
66051   }
66052   {
66053     try {
66054       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
66055     } catch (std::out_of_range& e) {
66056       {
66057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66058       };
66059     } catch (std::exception& e) {
66060       {
66061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66062       };
66063     } catch (...) {
66064       {
66065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66066       };
66067     }
66068   }
66069   jresult = (void *)result;
66070   return jresult;
66071 }
66072
66073
66074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
66075   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66076
66077   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66078   {
66079     try {
66080       delete arg1;
66081     } catch (std::out_of_range& e) {
66082       {
66083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66084       };
66085     } catch (std::exception& e) {
66086       {
66087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66088       };
66089     } catch (...) {
66090       {
66091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66092       };
66093     }
66094   }
66095 }
66096
66097
66098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
66099   void * jresult ;
66100   Dali::BaseHandle arg1 ;
66101   Dali::BaseHandle *argp1 ;
66102   Dali::Toolkit::Scrollable result;
66103
66104   argp1 = (Dali::BaseHandle *)jarg1;
66105   if (!argp1) {
66106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66107     return 0;
66108   }
66109   arg1 = *argp1;
66110   {
66111     try {
66112       result = Dali::Toolkit::Scrollable::DownCast(arg1);
66113     } catch (std::out_of_range& e) {
66114       {
66115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66116       };
66117     } catch (std::exception& e) {
66118       {
66119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66120       };
66121     } catch (...) {
66122       {
66123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66124       };
66125     }
66126   }
66127   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
66128   return jresult;
66129 }
66130
66131
66132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
66133   unsigned int jresult ;
66134   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66135   bool result;
66136
66137   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66138   {
66139     try {
66140       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
66141     } catch (std::out_of_range& e) {
66142       {
66143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66144       };
66145     } catch (std::exception& e) {
66146       {
66147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66148       };
66149     } catch (...) {
66150       {
66151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66152       };
66153     }
66154   }
66155   jresult = result;
66156   return jresult;
66157 }
66158
66159
66160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
66161   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66162   bool arg2 ;
66163
66164   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66165   arg2 = jarg2 ? true : false;
66166   {
66167     try {
66168       (arg1)->SetOvershootEnabled(arg2);
66169     } catch (std::out_of_range& e) {
66170       {
66171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66172       };
66173     } catch (std::exception& e) {
66174       {
66175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66176       };
66177     } catch (...) {
66178       {
66179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66180       };
66181     }
66182   }
66183 }
66184
66185
66186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
66187   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66188   Dali::Vector4 *arg2 = 0 ;
66189
66190   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66191   arg2 = (Dali::Vector4 *)jarg2;
66192   if (!arg2) {
66193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
66194     return ;
66195   }
66196   {
66197     try {
66198       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
66199     } catch (std::out_of_range& e) {
66200       {
66201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66202       };
66203     } catch (std::exception& e) {
66204       {
66205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66206       };
66207     } catch (...) {
66208       {
66209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66210       };
66211     }
66212   }
66213 }
66214
66215
66216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
66217   void * jresult ;
66218   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66219   Dali::Vector4 result;
66220
66221   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66222   {
66223     try {
66224       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
66225     } catch (std::out_of_range& e) {
66226       {
66227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66228       };
66229     } catch (std::exception& e) {
66230       {
66231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66232       };
66233     } catch (...) {
66234       {
66235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66236       };
66237     }
66238   }
66239   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
66240   return jresult;
66241 }
66242
66243
66244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
66245   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66246   float arg2 ;
66247
66248   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66249   arg2 = (float)jarg2;
66250   {
66251     try {
66252       (arg1)->SetOvershootAnimationSpeed(arg2);
66253     } catch (std::out_of_range& e) {
66254       {
66255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66256       };
66257     } catch (std::exception& e) {
66258       {
66259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66260       };
66261     } catch (...) {
66262       {
66263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66264       };
66265     }
66266   }
66267 }
66268
66269
66270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
66271   float jresult ;
66272   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66273   float result;
66274
66275   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66276   {
66277     try {
66278       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
66279     } catch (std::out_of_range& e) {
66280       {
66281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66282       };
66283     } catch (std::exception& e) {
66284       {
66285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66286       };
66287     } catch (...) {
66288       {
66289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66290       };
66291     }
66292   }
66293   jresult = result;
66294   return jresult;
66295 }
66296
66297
66298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
66299   void * jresult ;
66300   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66301   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
66302
66303   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66304   {
66305     try {
66306       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
66307     } catch (std::out_of_range& e) {
66308       {
66309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66310       };
66311     } catch (std::exception& e) {
66312       {
66313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66314       };
66315     } catch (...) {
66316       {
66317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66318       };
66319     }
66320   }
66321   jresult = (void *)result;
66322   return jresult;
66323 }
66324
66325
66326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
66327   void * jresult ;
66328   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66329   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
66330
66331   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66332   {
66333     try {
66334       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
66335     } catch (std::out_of_range& e) {
66336       {
66337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66338       };
66339     } catch (std::exception& e) {
66340       {
66341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66342       };
66343     } catch (...) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66346       };
66347     }
66348   }
66349   jresult = (void *)result;
66350   return jresult;
66351 }
66352
66353
66354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
66355   void * jresult ;
66356   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66357   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
66358
66359   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66360   {
66361     try {
66362       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
66363     } catch (std::out_of_range& e) {
66364       {
66365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66366       };
66367     } catch (std::exception& e) {
66368       {
66369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66370       };
66371     } catch (...) {
66372       {
66373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66374       };
66375     }
66376   }
66377   jresult = (void *)result;
66378   return jresult;
66379 }
66380
66381
66382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
66383   unsigned int jresult ;
66384   Dali::Toolkit::ControlOrientation::Type arg1 ;
66385   bool result;
66386
66387   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
66388   {
66389     try {
66390       result = (bool)Dali::Toolkit::IsVertical(arg1);
66391     } catch (std::out_of_range& e) {
66392       {
66393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66394       };
66395     } catch (std::exception& e) {
66396       {
66397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66398       };
66399     } catch (...) {
66400       {
66401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66402       };
66403     }
66404   }
66405   jresult = result;
66406   return jresult;
66407 }
66408
66409
66410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
66411   unsigned int jresult ;
66412   Dali::Toolkit::ControlOrientation::Type arg1 ;
66413   bool result;
66414
66415   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
66416   {
66417     try {
66418       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
66419     } catch (std::out_of_range& e) {
66420       {
66421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66422       };
66423     } catch (std::exception& e) {
66424       {
66425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66426       };
66427     } catch (...) {
66428       {
66429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66430       };
66431     }
66432   }
66433   jresult = result;
66434   return jresult;
66435 }
66436
66437
66438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
66439   void * jresult ;
66440   unsigned int arg1 ;
66441   unsigned int arg2 ;
66442   Dali::Toolkit::ItemRange *result = 0 ;
66443
66444   arg1 = (unsigned int)jarg1;
66445   arg2 = (unsigned int)jarg2;
66446   {
66447     try {
66448       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
66449     } catch (std::out_of_range& e) {
66450       {
66451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66452       };
66453     } catch (std::exception& e) {
66454       {
66455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66456       };
66457     } catch (...) {
66458       {
66459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66460       };
66461     }
66462   }
66463   jresult = (void *)result;
66464   return jresult;
66465 }
66466
66467
66468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
66469   void * jresult ;
66470   Dali::Toolkit::ItemRange *arg1 = 0 ;
66471   Dali::Toolkit::ItemRange *result = 0 ;
66472
66473   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66474   if (!arg1) {
66475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66476     return 0;
66477   }
66478   {
66479     try {
66480       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
66481     } catch (std::out_of_range& e) {
66482       {
66483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66484       };
66485     } catch (std::exception& e) {
66486       {
66487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66488       };
66489     } catch (...) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66492       };
66493     }
66494   }
66495   jresult = (void *)result;
66496   return jresult;
66497 }
66498
66499
66500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
66501   void * jresult ;
66502   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66503   Dali::Toolkit::ItemRange *arg2 = 0 ;
66504   Dali::Toolkit::ItemRange *result = 0 ;
66505
66506   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66507   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66508   if (!arg2) {
66509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66510     return 0;
66511   }
66512   {
66513     try {
66514       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
66515     } catch (std::out_of_range& e) {
66516       {
66517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66518       };
66519     } catch (std::exception& e) {
66520       {
66521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (...) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66526       };
66527     }
66528   }
66529   jresult = (void *)result;
66530   return jresult;
66531 }
66532
66533
66534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
66535   unsigned int jresult ;
66536   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66537   unsigned int arg2 ;
66538   bool result;
66539
66540   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66541   arg2 = (unsigned int)jarg2;
66542   {
66543     try {
66544       result = (bool)(arg1)->Within(arg2);
66545     } catch (std::out_of_range& e) {
66546       {
66547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66548       };
66549     } catch (std::exception& e) {
66550       {
66551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66552       };
66553     } catch (...) {
66554       {
66555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66556       };
66557     }
66558   }
66559   jresult = result;
66560   return jresult;
66561 }
66562
66563
66564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
66565   void * jresult ;
66566   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66567   Dali::Toolkit::ItemRange *arg2 = 0 ;
66568   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
66569
66570   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66571   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66572   if (!arg2) {
66573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66574     return 0;
66575   }
66576   {
66577     try {
66578       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
66579     } catch (std::out_of_range& e) {
66580       {
66581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66582       };
66583     } catch (std::exception& e) {
66584       {
66585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66586       };
66587     } catch (...) {
66588       {
66589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66590       };
66591     }
66592   }
66593   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
66594   return jresult;
66595 }
66596
66597
66598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
66599   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66600   unsigned int arg2 ;
66601
66602   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66603   arg2 = (unsigned int)jarg2;
66604   if (arg1) (arg1)->begin = arg2;
66605 }
66606
66607
66608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
66609   unsigned int jresult ;
66610   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66611   unsigned int result;
66612
66613   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66614   result = (unsigned int) ((arg1)->begin);
66615   jresult = result;
66616   return jresult;
66617 }
66618
66619
66620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
66621   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66622   unsigned int arg2 ;
66623
66624   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66625   arg2 = (unsigned int)jarg2;
66626   if (arg1) (arg1)->end = arg2;
66627 }
66628
66629
66630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
66631   unsigned int jresult ;
66632   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66633   unsigned int result;
66634
66635   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66636   result = (unsigned int) ((arg1)->end);
66637   jresult = result;
66638   return jresult;
66639 }
66640
66641
66642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
66643   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66644
66645   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66646   {
66647     try {
66648       delete arg1;
66649     } catch (std::out_of_range& e) {
66650       {
66651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66652       };
66653     } catch (std::exception& e) {
66654       {
66655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66656       };
66657     } catch (...) {
66658       {
66659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66660       };
66661     }
66662   }
66663 }
66664
66665
66666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
66667   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66668
66669   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66670   {
66671     try {
66672       delete arg1;
66673     } catch (std::out_of_range& e) {
66674       {
66675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66676       };
66677     } catch (std::exception& e) {
66678       {
66679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66680       };
66681     } catch (...) {
66682       {
66683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66684       };
66685     }
66686   }
66687 }
66688
66689
66690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
66691   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66692   Dali::Toolkit::ControlOrientation::Type arg2 ;
66693
66694   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66695   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
66696   {
66697     try {
66698       (arg1)->SetOrientation(arg2);
66699     } catch (std::out_of_range& e) {
66700       {
66701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66702       };
66703     } catch (std::exception& e) {
66704       {
66705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66706       };
66707     } catch (...) {
66708       {
66709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66710       };
66711     }
66712   }
66713 }
66714
66715
66716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
66717   int jresult ;
66718   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66719   Dali::Toolkit::ControlOrientation::Type result;
66720
66721   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66722   {
66723     try {
66724       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
66725     } catch (std::out_of_range& e) {
66726       {
66727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66728       };
66729     } catch (std::exception& e) {
66730       {
66731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66732       };
66733     } catch (...) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66736       };
66737     }
66738   }
66739   jresult = (int)result;
66740   return jresult;
66741 }
66742
66743
66744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
66745   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66746   Dali::Property::Map *arg2 = 0 ;
66747
66748   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66749   arg2 = (Dali::Property::Map *)jarg2;
66750   if (!arg2) {
66751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
66752     return ;
66753   }
66754   {
66755     try {
66756       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
66757     } catch (std::out_of_range& e) {
66758       {
66759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66760       };
66761     } catch (std::exception& e) {
66762       {
66763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66764       };
66765     } catch (...) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66768       };
66769     }
66770   }
66771 }
66772
66773
66774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
66775   void * jresult ;
66776   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66777   Dali::Property::Map result;
66778
66779   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66780   {
66781     try {
66782       result = (arg1)->GetLayoutProperties();
66783     } catch (std::out_of_range& e) {
66784       {
66785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66786       };
66787     } catch (std::exception& e) {
66788       {
66789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66790       };
66791     } catch (...) {
66792       {
66793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66794       };
66795     }
66796   }
66797   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
66798   return jresult;
66799 }
66800
66801
66802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
66803   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66804   unsigned int arg2 ;
66805   Dali::Vector3 *arg3 = 0 ;
66806   Dali::Vector3 *arg4 = 0 ;
66807
66808   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66809   arg2 = (unsigned int)jarg2;
66810   arg3 = (Dali::Vector3 *)jarg3;
66811   if (!arg3) {
66812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66813     return ;
66814   }
66815   arg4 = (Dali::Vector3 *)jarg4;
66816   if (!arg4) {
66817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66818     return ;
66819   }
66820   {
66821     try {
66822       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
66823     } catch (std::out_of_range& e) {
66824       {
66825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66826       };
66827     } catch (std::exception& e) {
66828       {
66829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66830       };
66831     } catch (...) {
66832       {
66833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66834       };
66835     }
66836   }
66837 }
66838
66839
66840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
66841   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66842   Dali::Vector3 *arg2 = 0 ;
66843
66844   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66845   arg2 = (Dali::Vector3 *)jarg2;
66846   if (!arg2) {
66847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66848     return ;
66849   }
66850   {
66851     try {
66852       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
66853     } catch (std::out_of_range& e) {
66854       {
66855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66856       };
66857     } catch (std::exception& e) {
66858       {
66859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66860       };
66861     } catch (...) {
66862       {
66863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66864       };
66865     }
66866   }
66867 }
66868
66869
66870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
66871   float jresult ;
66872   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66873   unsigned int arg2 ;
66874   Dali::Vector3 arg3 ;
66875   Dali::Vector3 *argp3 ;
66876   float result;
66877
66878   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66879   arg2 = (unsigned int)jarg2;
66880   argp3 = (Dali::Vector3 *)jarg3;
66881   if (!argp3) {
66882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66883     return 0;
66884   }
66885   arg3 = *argp3;
66886   {
66887     try {
66888       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
66889     } catch (std::out_of_range& e) {
66890       {
66891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66892       };
66893     } catch (std::exception& e) {
66894       {
66895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66896       };
66897     } catch (...) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66900       };
66901     }
66902   }
66903   jresult = result;
66904   return jresult;
66905 }
66906
66907
66908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
66909   float jresult ;
66910   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66911   float arg2 ;
66912   float result;
66913
66914   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66915   arg2 = (float)jarg2;
66916   {
66917     try {
66918       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
66919     } catch (std::out_of_range& e) {
66920       {
66921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66922       };
66923     } catch (std::exception& e) {
66924       {
66925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66926       };
66927     } catch (...) {
66928       {
66929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66930       };
66931     }
66932   }
66933   jresult = result;
66934   return jresult;
66935 }
66936
66937
66938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
66939   float jresult ;
66940   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66941   unsigned int arg2 ;
66942   float result;
66943
66944   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66945   arg2 = (unsigned int)jarg2;
66946   {
66947     try {
66948       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
66949     } catch (std::out_of_range& e) {
66950       {
66951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (std::exception& e) {
66954       {
66955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66956       };
66957     } catch (...) {
66958       {
66959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66960       };
66961     }
66962   }
66963   jresult = result;
66964   return jresult;
66965 }
66966
66967
66968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
66969   void * jresult ;
66970   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66971   float arg2 ;
66972   Dali::Vector3 arg3 ;
66973   Dali::Vector3 *argp3 ;
66974   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
66975
66976   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66977   arg2 = (float)jarg2;
66978   argp3 = (Dali::Vector3 *)jarg3;
66979   if (!argp3) {
66980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66981     return 0;
66982   }
66983   arg3 = *argp3;
66984   {
66985     try {
66986       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
66987     } catch (std::out_of_range& e) {
66988       {
66989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66990       };
66991     } catch (std::exception& e) {
66992       {
66993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66994       };
66995     } catch (...) {
66996       {
66997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66998       };
66999     }
67000   }
67001   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
67002   return jresult;
67003 }
67004
67005
67006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
67007   float jresult ;
67008   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67009   int arg2 ;
67010   float arg3 ;
67011   Dali::Vector3 *arg4 = 0 ;
67012   float result;
67013
67014   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67015   arg2 = (int)jarg2;
67016   arg3 = (float)jarg3;
67017   arg4 = (Dali::Vector3 *)jarg4;
67018   if (!arg4) {
67019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67020     return 0;
67021   }
67022   {
67023     try {
67024       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
67025     } catch (std::out_of_range& e) {
67026       {
67027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67028       };
67029     } catch (std::exception& e) {
67030       {
67031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67032       };
67033     } catch (...) {
67034       {
67035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67036       };
67037     }
67038   }
67039   jresult = result;
67040   return jresult;
67041 }
67042
67043
67044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
67045   unsigned int jresult ;
67046   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67047   Dali::Vector3 arg2 ;
67048   Dali::Vector3 *argp2 ;
67049   unsigned int result;
67050
67051   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67052   argp2 = (Dali::Vector3 *)jarg2;
67053   if (!argp2) {
67054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
67055     return 0;
67056   }
67057   arg2 = *argp2;
67058   {
67059     try {
67060       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
67061     } catch (std::out_of_range& e) {
67062       {
67063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67064       };
67065     } catch (std::exception& e) {
67066       {
67067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67068       };
67069     } catch (...) {
67070       {
67071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67072       };
67073     }
67074   }
67075   jresult = result;
67076   return jresult;
67077 }
67078
67079
67080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
67081   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67082   unsigned int arg2 ;
67083   Dali::Vector3 *arg3 = 0 ;
67084   Dali::Vector3 *arg4 = 0 ;
67085
67086   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67087   arg2 = (unsigned int)jarg2;
67088   arg3 = (Dali::Vector3 *)jarg3;
67089   if (!arg3) {
67090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67091     return ;
67092   }
67093   arg4 = (Dali::Vector3 *)jarg4;
67094   if (!arg4) {
67095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
67096     return ;
67097   }
67098   {
67099     try {
67100       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
67101     } catch (std::out_of_range& e) {
67102       {
67103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67104       };
67105     } catch (std::exception& e) {
67106       {
67107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67108       };
67109     } catch (...) {
67110       {
67111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67112       };
67113     }
67114   }
67115 }
67116
67117
67118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
67119   void * jresult ;
67120   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67121   Dali::Degree result;
67122
67123   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67124   {
67125     try {
67126       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
67127     } catch (std::out_of_range& e) {
67128       {
67129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67130       };
67131     } catch (std::exception& e) {
67132       {
67133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67134       };
67135     } catch (...) {
67136       {
67137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67138       };
67139     }
67140   }
67141   jresult = new Dali::Degree((const Dali::Degree &)result);
67142   return jresult;
67143 }
67144
67145
67146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
67147   float jresult ;
67148   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67149   float result;
67150
67151   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67152   {
67153     try {
67154       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
67155     } catch (std::out_of_range& e) {
67156       {
67157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67158       };
67159     } catch (std::exception& e) {
67160       {
67161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67162       };
67163     } catch (...) {
67164       {
67165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67166       };
67167     }
67168   }
67169   jresult = result;
67170   return jresult;
67171 }
67172
67173
67174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
67175   float jresult ;
67176   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67177   float result;
67178
67179   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67180   {
67181     try {
67182       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
67183     } catch (std::out_of_range& e) {
67184       {
67185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (std::exception& e) {
67188       {
67189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67194       };
67195     }
67196   }
67197   jresult = result;
67198   return jresult;
67199 }
67200
67201
67202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
67203   float jresult ;
67204   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67205   float result;
67206
67207   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67208   {
67209     try {
67210       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
67211     } catch (std::out_of_range& e) {
67212       {
67213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67214       };
67215     } catch (std::exception& e) {
67216       {
67217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67218       };
67219     } catch (...) {
67220       {
67221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67222       };
67223     }
67224   }
67225   jresult = result;
67226   return jresult;
67227 }
67228
67229
67230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
67231   int jresult ;
67232   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67233   int arg2 ;
67234   int arg3 ;
67235   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
67236   bool arg5 ;
67237   int result;
67238
67239   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67240   arg2 = (int)jarg2;
67241   arg3 = (int)jarg3;
67242   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
67243   arg5 = jarg5 ? true : false;
67244   {
67245     try {
67246       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
67247     } catch (std::out_of_range& e) {
67248       {
67249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67250       };
67251     } catch (std::exception& e) {
67252       {
67253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67254       };
67255     } catch (...) {
67256       {
67257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67258       };
67259     }
67260   }
67261   jresult = result;
67262   return jresult;
67263 }
67264
67265
67266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
67267   float jresult ;
67268   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67269   float result;
67270
67271   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67272   {
67273     try {
67274       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
67275     } catch (std::out_of_range& e) {
67276       {
67277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67278       };
67279     } catch (std::exception& e) {
67280       {
67281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67282       };
67283     } catch (...) {
67284       {
67285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67286       };
67287     }
67288   }
67289   jresult = result;
67290   return jresult;
67291 }
67292
67293
67294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
67295   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67296   Dali::Actor *arg2 = 0 ;
67297   int arg3 ;
67298   Dali::Vector3 *arg4 = 0 ;
67299   Dali::Actor *arg5 = 0 ;
67300
67301   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67302   arg2 = (Dali::Actor *)jarg2;
67303   if (!arg2) {
67304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
67305     return ;
67306   }
67307   arg3 = (int)jarg3;
67308   arg4 = (Dali::Vector3 *)jarg4;
67309   if (!arg4) {
67310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67311     return ;
67312   }
67313   arg5 = (Dali::Actor *)jarg5;
67314   if (!arg5) {
67315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
67316     return ;
67317   }
67318   {
67319     try {
67320       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
67321     } catch (std::out_of_range& e) {
67322       {
67323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67324       };
67325     } catch (std::exception& e) {
67326       {
67327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67328       };
67329     } catch (...) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67332       };
67333     }
67334   }
67335 }
67336
67337
67338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
67339   void * jresult ;
67340   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67341   int arg2 ;
67342   float arg3 ;
67343   Dali::Vector3 *arg4 = 0 ;
67344   Dali::Vector3 result;
67345
67346   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67347   arg2 = (int)jarg2;
67348   arg3 = (float)jarg3;
67349   arg4 = (Dali::Vector3 *)jarg4;
67350   if (!arg4) {
67351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67352     return 0;
67353   }
67354   {
67355     try {
67356       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
67357     } catch (std::out_of_range& e) {
67358       {
67359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67360       };
67361     } catch (std::exception& e) {
67362       {
67363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67364       };
67365     } catch (...) {
67366       {
67367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67368       };
67369     }
67370   }
67371   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
67372   return jresult;
67373 }
67374
67375
67376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
67377   void * jresult ;
67378   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
67379   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
67380
67381   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
67382   {
67383     try {
67384       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
67385     } catch (std::out_of_range& e) {
67386       {
67387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67388       };
67389     } catch (std::exception& e) {
67390       {
67391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67392       };
67393     } catch (...) {
67394       {
67395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67396       };
67397     }
67398   }
67399   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
67400   return jresult;
67401 }
67402
67403
67404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
67405   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67406
67407   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67408   {
67409     try {
67410       delete arg1;
67411     } catch (std::out_of_range& e) {
67412       {
67413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67414       };
67415     } catch (std::exception& e) {
67416       {
67417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67418       };
67419     } catch (...) {
67420       {
67421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67422       };
67423     }
67424   }
67425 }
67426
67427
67428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
67429   unsigned int jresult ;
67430   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67431   unsigned int result;
67432
67433   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67434   {
67435     try {
67436       result = (unsigned int)(arg1)->GetNumberOfItems();
67437     } catch (std::out_of_range& e) {
67438       {
67439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67440       };
67441     } catch (std::exception& e) {
67442       {
67443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67444       };
67445     } catch (...) {
67446       {
67447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67448       };
67449     }
67450   }
67451   jresult = result;
67452   return jresult;
67453 }
67454
67455
67456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
67457   void * jresult ;
67458   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67459   unsigned int arg2 ;
67460   Dali::Actor result;
67461
67462   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67463   arg2 = (unsigned int)jarg2;
67464   {
67465     try {
67466       result = (arg1)->NewItem(arg2);
67467     } catch (std::out_of_range& e) {
67468       {
67469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67470       };
67471     } catch (std::exception& e) {
67472       {
67473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67474       };
67475     } catch (...) {
67476       {
67477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67478       };
67479     }
67480   }
67481   jresult = new Dali::Actor((const Dali::Actor &)result);
67482   return jresult;
67483 }
67484
67485
67486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
67487   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67488   unsigned int arg2 ;
67489   Dali::Actor arg3 ;
67490   Dali::Actor *argp3 ;
67491
67492   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67493   arg2 = (unsigned int)jarg2;
67494   argp3 = (Dali::Actor *)jarg3;
67495   if (!argp3) {
67496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67497     return ;
67498   }
67499   arg3 = *argp3;
67500   {
67501     try {
67502       (arg1)->ItemReleased(arg2,arg3);
67503     } catch (std::out_of_range& e) {
67504       {
67505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67506       };
67507     } catch (std::exception& e) {
67508       {
67509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67510       };
67511     } catch (...) {
67512       {
67513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67514       };
67515     }
67516   }
67517 }
67518
67519
67520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
67521   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67522   unsigned int arg2 ;
67523   Dali::Actor arg3 ;
67524   Dali::Actor *argp3 ;
67525
67526   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67527   arg2 = (unsigned int)jarg2;
67528   argp3 = (Dali::Actor *)jarg3;
67529   if (!argp3) {
67530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67531     return ;
67532   }
67533   arg3 = *argp3;
67534   {
67535     try {
67536       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
67537     } catch (std::out_of_range& e) {
67538       {
67539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67540       };
67541     } catch (std::exception& e) {
67542       {
67543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67544       };
67545     } catch (...) {
67546       {
67547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67548       };
67549     }
67550   }
67551 }
67552
67553
67554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
67555   void * jresult ;
67556   Dali::Toolkit::ItemFactory *result = 0 ;
67557
67558   {
67559     try {
67560       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
67561     } catch (std::out_of_range& e) {
67562       {
67563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67564       };
67565     } catch (std::exception& e) {
67566       {
67567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67568       };
67569     } catch (...) {
67570       {
67571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67572       };
67573     }
67574   }
67575   jresult = (void *)result;
67576   return jresult;
67577 }
67578
67579
67580 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) {
67581   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
67582   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
67583   if (director) {
67584     director->swig_connect_director(callback0, callback1, callback2);
67585   }
67586 }
67587
67588
67589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
67590   int jresult ;
67591   int result;
67592
67593   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
67594   jresult = (int)result;
67595   return jresult;
67596 }
67597
67598
67599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
67600   int jresult ;
67601   int result;
67602
67603   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
67604   jresult = (int)result;
67605   return jresult;
67606 }
67607
67608
67609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
67610   int jresult ;
67611   int result;
67612
67613   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
67614   jresult = (int)result;
67615   return jresult;
67616 }
67617
67618
67619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
67620   int jresult ;
67621   int result;
67622
67623   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
67624   jresult = (int)result;
67625   return jresult;
67626 }
67627
67628
67629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
67630   int jresult ;
67631   int result;
67632
67633   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
67634   jresult = (int)result;
67635   return jresult;
67636 }
67637
67638
67639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
67640   int jresult ;
67641   int result;
67642
67643   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
67644   jresult = (int)result;
67645   return jresult;
67646 }
67647
67648
67649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
67650   int jresult ;
67651   int result;
67652
67653   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
67654   jresult = (int)result;
67655   return jresult;
67656 }
67657
67658
67659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
67660   int jresult ;
67661   int result;
67662
67663   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
67664   jresult = (int)result;
67665   return jresult;
67666 }
67667
67668
67669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
67670   int jresult ;
67671   int result;
67672
67673   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
67674   jresult = (int)result;
67675   return jresult;
67676 }
67677
67678
67679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
67680   int jresult ;
67681   int result;
67682
67683   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
67684   jresult = (int)result;
67685   return jresult;
67686 }
67687
67688
67689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
67690   int jresult ;
67691   int result;
67692
67693   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
67694   jresult = (int)result;
67695   return jresult;
67696 }
67697
67698
67699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
67700   void * jresult ;
67701   Dali::Toolkit::ItemView::Property *result = 0 ;
67702
67703   {
67704     try {
67705       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
67706     } catch (std::out_of_range& e) {
67707       {
67708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67709       };
67710     } catch (std::exception& e) {
67711       {
67712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67713       };
67714     } catch (...) {
67715       {
67716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67717       };
67718     }
67719   }
67720   jresult = (void *)result;
67721   return jresult;
67722 }
67723
67724
67725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
67726   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
67727
67728   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
67729   {
67730     try {
67731       delete arg1;
67732     } catch (std::out_of_range& e) {
67733       {
67734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67735       };
67736     } catch (std::exception& e) {
67737       {
67738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67739       };
67740     } catch (...) {
67741       {
67742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67743       };
67744     }
67745   }
67746 }
67747
67748
67749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
67750   void * jresult ;
67751   Dali::Toolkit::ItemView *result = 0 ;
67752
67753   {
67754     try {
67755       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
67756     } catch (std::out_of_range& e) {
67757       {
67758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67759       };
67760     } catch (std::exception& e) {
67761       {
67762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67763       };
67764     } catch (...) {
67765       {
67766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67767       };
67768     }
67769   }
67770   jresult = (void *)result;
67771   return jresult;
67772 }
67773
67774
67775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
67776   void * jresult ;
67777   Dali::Toolkit::ItemView *arg1 = 0 ;
67778   Dali::Toolkit::ItemView *result = 0 ;
67779
67780   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67781   if (!arg1) {
67782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
67783     return 0;
67784   }
67785   {
67786     try {
67787       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
67788     } catch (std::out_of_range& e) {
67789       {
67790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67791       };
67792     } catch (std::exception& e) {
67793       {
67794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67795       };
67796     } catch (...) {
67797       {
67798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67799       };
67800     }
67801   }
67802   jresult = (void *)result;
67803   return jresult;
67804 }
67805
67806
67807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
67808   void * jresult ;
67809   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67810   Dali::Toolkit::ItemView *arg2 = 0 ;
67811   Dali::Toolkit::ItemView *result = 0 ;
67812
67813   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67814   arg2 = (Dali::Toolkit::ItemView *)jarg2;
67815   if (!arg2) {
67816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
67817     return 0;
67818   }
67819   {
67820     try {
67821       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
67822     } catch (std::out_of_range& e) {
67823       {
67824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67825       };
67826     } catch (std::exception& e) {
67827       {
67828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67829       };
67830     } catch (...) {
67831       {
67832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67833       };
67834     }
67835   }
67836   jresult = (void *)result;
67837   return jresult;
67838 }
67839
67840
67841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
67842   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67843
67844   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67845   {
67846     try {
67847       delete arg1;
67848     } catch (std::out_of_range& e) {
67849       {
67850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67851       };
67852     } catch (std::exception& e) {
67853       {
67854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67855       };
67856     } catch (...) {
67857       {
67858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67859       };
67860     }
67861   }
67862 }
67863
67864
67865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
67866   void * jresult ;
67867   Dali::Toolkit::ItemFactory *arg1 = 0 ;
67868   Dali::Toolkit::ItemView result;
67869
67870   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67871   if (!arg1) {
67872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
67873     return 0;
67874   }
67875   {
67876     try {
67877       result = Dali::Toolkit::ItemView::New(*arg1);
67878     } catch (std::out_of_range& e) {
67879       {
67880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67881       };
67882     } catch (std::exception& e) {
67883       {
67884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67885       };
67886     } catch (...) {
67887       {
67888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67889       };
67890     }
67891   }
67892   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
67893   return jresult;
67894 }
67895
67896
67897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
67898   void * jresult ;
67899   Dali::BaseHandle arg1 ;
67900   Dali::BaseHandle *argp1 ;
67901   Dali::Toolkit::ItemView result;
67902
67903   argp1 = (Dali::BaseHandle *)jarg1;
67904   if (!argp1) {
67905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67906     return 0;
67907   }
67908   arg1 = *argp1;
67909   {
67910     try {
67911       result = Dali::Toolkit::ItemView::DownCast(arg1);
67912     } catch (std::out_of_range& e) {
67913       {
67914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67915       };
67916     } catch (std::exception& e) {
67917       {
67918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67919       };
67920     } catch (...) {
67921       {
67922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67923       };
67924     }
67925   }
67926   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
67927   return jresult;
67928 }
67929
67930
67931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
67932   unsigned int jresult ;
67933   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67934   unsigned int result;
67935
67936   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67937   {
67938     try {
67939       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
67940     } catch (std::out_of_range& e) {
67941       {
67942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67943       };
67944     } catch (std::exception& e) {
67945       {
67946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67947       };
67948     } catch (...) {
67949       {
67950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67951       };
67952     }
67953   }
67954   jresult = result;
67955   return jresult;
67956 }
67957
67958
67959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
67960   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67961   Dali::Toolkit::ItemLayout *arg2 = 0 ;
67962
67963   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67964   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
67965   if (!arg2) {
67966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
67967     return ;
67968   }
67969   {
67970     try {
67971       (arg1)->AddLayout(*arg2);
67972     } catch (std::out_of_range& e) {
67973       {
67974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67975       };
67976     } catch (std::exception& e) {
67977       {
67978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67979       };
67980     } catch (...) {
67981       {
67982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67983       };
67984     }
67985   }
67986 }
67987
67988
67989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
67990   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67991   unsigned int arg2 ;
67992
67993   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67994   arg2 = (unsigned int)jarg2;
67995   {
67996     try {
67997       (arg1)->RemoveLayout(arg2);
67998     } catch (std::out_of_range& e) {
67999       {
68000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68001       };
68002     } catch (std::exception& e) {
68003       {
68004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68005       };
68006     } catch (...) {
68007       {
68008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68009       };
68010     }
68011   }
68012 }
68013
68014
68015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
68016   void * jresult ;
68017   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68018   unsigned int arg2 ;
68019   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68020
68021   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68022   arg2 = (unsigned int)jarg2;
68023   {
68024     try {
68025       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
68026     } catch (std::out_of_range& e) {
68027       {
68028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68029       };
68030     } catch (std::exception& e) {
68031       {
68032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68033       };
68034     } catch (...) {
68035       {
68036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68037       };
68038     }
68039   }
68040   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68041   return jresult;
68042 }
68043
68044
68045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
68046   void * jresult ;
68047   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68048   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68049
68050   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68051   {
68052     try {
68053       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
68054     } catch (std::out_of_range& e) {
68055       {
68056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68057       };
68058     } catch (std::exception& e) {
68059       {
68060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (...) {
68063       {
68064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68065       };
68066     }
68067   }
68068   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68069   return jresult;
68070 }
68071
68072
68073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
68074   float jresult ;
68075   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68076   Dali::Toolkit::ItemId arg2 ;
68077   float result;
68078
68079   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68080   arg2 = (Dali::Toolkit::ItemId)jarg2;
68081   {
68082     try {
68083       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
68084     } catch (std::out_of_range& e) {
68085       {
68086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68087       };
68088     } catch (std::exception& e) {
68089       {
68090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68091       };
68092     } catch (...) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68095       };
68096     }
68097   }
68098   jresult = result;
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
68104   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68105   unsigned int arg2 ;
68106   Dali::Vector3 arg3 ;
68107   float arg4 ;
68108   Dali::Vector3 *argp3 ;
68109
68110   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68111   arg2 = (unsigned int)jarg2;
68112   argp3 = (Dali::Vector3 *)jarg3;
68113   if (!argp3) {
68114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68115     return ;
68116   }
68117   arg3 = *argp3;
68118   arg4 = (float)jarg4;
68119   {
68120     try {
68121       (arg1)->ActivateLayout(arg2,arg3,arg4);
68122     } catch (std::out_of_range& e) {
68123       {
68124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68125       };
68126     } catch (std::exception& e) {
68127       {
68128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68129       };
68130     } catch (...) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68133       };
68134     }
68135   }
68136 }
68137
68138
68139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
68140   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68141
68142   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68143   {
68144     try {
68145       (arg1)->DeactivateCurrentLayout();
68146     } catch (std::out_of_range& e) {
68147       {
68148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68149       };
68150     } catch (std::exception& e) {
68151       {
68152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68153       };
68154     } catch (...) {
68155       {
68156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68157       };
68158     }
68159   }
68160 }
68161
68162
68163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
68164   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68165   float arg2 ;
68166
68167   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68168   arg2 = (float)jarg2;
68169   {
68170     try {
68171       (arg1)->SetMinimumSwipeSpeed(arg2);
68172     } catch (std::out_of_range& e) {
68173       {
68174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68175       };
68176     } catch (std::exception& e) {
68177       {
68178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68179       };
68180     } catch (...) {
68181       {
68182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68183       };
68184     }
68185   }
68186 }
68187
68188
68189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
68190   float jresult ;
68191   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68192   float result;
68193
68194   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68195   {
68196     try {
68197       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
68198     } catch (std::out_of_range& e) {
68199       {
68200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68201       };
68202     } catch (std::exception& e) {
68203       {
68204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68205       };
68206     } catch (...) {
68207       {
68208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68209       };
68210     }
68211   }
68212   jresult = result;
68213   return jresult;
68214 }
68215
68216
68217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
68218   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68219   float arg2 ;
68220
68221   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68222   arg2 = (float)jarg2;
68223   {
68224     try {
68225       (arg1)->SetMinimumSwipeDistance(arg2);
68226     } catch (std::out_of_range& e) {
68227       {
68228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68229       };
68230     } catch (std::exception& e) {
68231       {
68232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68233       };
68234     } catch (...) {
68235       {
68236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68237       };
68238     }
68239   }
68240 }
68241
68242
68243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
68244   float jresult ;
68245   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68246   float result;
68247
68248   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68249   {
68250     try {
68251       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
68252     } catch (std::out_of_range& e) {
68253       {
68254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68255       };
68256     } catch (std::exception& e) {
68257       {
68258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (...) {
68261       {
68262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68263       };
68264     }
68265   }
68266   jresult = result;
68267   return jresult;
68268 }
68269
68270
68271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
68272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68273   float arg2 ;
68274
68275   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68276   arg2 = (float)jarg2;
68277   {
68278     try {
68279       (arg1)->SetWheelScrollDistanceStep(arg2);
68280     } catch (std::out_of_range& e) {
68281       {
68282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68283       };
68284     } catch (std::exception& e) {
68285       {
68286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68287       };
68288     } catch (...) {
68289       {
68290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68291       };
68292     }
68293   }
68294 }
68295
68296
68297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
68298   float jresult ;
68299   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68300   float result;
68301
68302   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68303   {
68304     try {
68305       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
68306     } catch (std::out_of_range& e) {
68307       {
68308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68309       };
68310     } catch (std::exception& e) {
68311       {
68312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68313       };
68314     } catch (...) {
68315       {
68316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68317       };
68318     }
68319   }
68320   jresult = result;
68321   return jresult;
68322 }
68323
68324
68325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
68326   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68327   bool arg2 ;
68328
68329   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68330   arg2 = jarg2 ? true : false;
68331   {
68332     try {
68333       (arg1)->SetAnchoring(arg2);
68334     } catch (std::out_of_range& e) {
68335       {
68336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68337       };
68338     } catch (std::exception& e) {
68339       {
68340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68341       };
68342     } catch (...) {
68343       {
68344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68345       };
68346     }
68347   }
68348 }
68349
68350
68351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
68352   unsigned int jresult ;
68353   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68354   bool result;
68355
68356   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68357   {
68358     try {
68359       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
68360     } catch (std::out_of_range& e) {
68361       {
68362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68363       };
68364     } catch (std::exception& e) {
68365       {
68366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68367       };
68368     } catch (...) {
68369       {
68370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68371       };
68372     }
68373   }
68374   jresult = result;
68375   return jresult;
68376 }
68377
68378
68379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
68380   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68381   float arg2 ;
68382
68383   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68384   arg2 = (float)jarg2;
68385   {
68386     try {
68387       (arg1)->SetAnchoringDuration(arg2);
68388     } catch (std::out_of_range& e) {
68389       {
68390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68391       };
68392     } catch (std::exception& e) {
68393       {
68394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68395       };
68396     } catch (...) {
68397       {
68398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68399       };
68400     }
68401   }
68402 }
68403
68404
68405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
68406   float jresult ;
68407   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68408   float result;
68409
68410   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68411   {
68412     try {
68413       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
68414     } catch (std::out_of_range& e) {
68415       {
68416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68417       };
68418     } catch (std::exception& e) {
68419       {
68420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68421       };
68422     } catch (...) {
68423       {
68424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68425       };
68426     }
68427   }
68428   jresult = result;
68429   return jresult;
68430 }
68431
68432
68433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
68434   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68435   Dali::Toolkit::ItemId arg2 ;
68436   float arg3 ;
68437
68438   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68439   arg2 = (Dali::Toolkit::ItemId)jarg2;
68440   arg3 = (float)jarg3;
68441   {
68442     try {
68443       (arg1)->ScrollToItem(arg2,arg3);
68444     } catch (std::out_of_range& e) {
68445       {
68446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68447       };
68448     } catch (std::exception& e) {
68449       {
68450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68451       };
68452     } catch (...) {
68453       {
68454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68455       };
68456     }
68457   }
68458 }
68459
68460
68461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
68462   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68463   float arg2 ;
68464
68465   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68466   arg2 = (float)jarg2;
68467   {
68468     try {
68469       (arg1)->SetRefreshInterval(arg2);
68470     } catch (std::out_of_range& e) {
68471       {
68472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68473       };
68474     } catch (std::exception& e) {
68475       {
68476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68477       };
68478     } catch (...) {
68479       {
68480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68481       };
68482     }
68483   }
68484 }
68485
68486
68487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
68488   float jresult ;
68489   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68490   float result;
68491
68492   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68493   {
68494     try {
68495       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
68496     } catch (std::out_of_range& e) {
68497       {
68498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68499       };
68500     } catch (std::exception& e) {
68501       {
68502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68503       };
68504     } catch (...) {
68505       {
68506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68507       };
68508     }
68509   }
68510   jresult = result;
68511   return jresult;
68512 }
68513
68514
68515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
68516   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68517
68518   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68519   {
68520     try {
68521       (arg1)->Refresh();
68522     } catch (std::out_of_range& e) {
68523       {
68524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68525       };
68526     } catch (std::exception& e) {
68527       {
68528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68529       };
68530     } catch (...) {
68531       {
68532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68533       };
68534     }
68535   }
68536 }
68537
68538
68539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
68540   void * jresult ;
68541   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68542   Dali::Toolkit::ItemId arg2 ;
68543   Dali::Actor result;
68544
68545   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68546   arg2 = (Dali::Toolkit::ItemId)jarg2;
68547   {
68548     try {
68549       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
68550     } catch (std::out_of_range& e) {
68551       {
68552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68553       };
68554     } catch (std::exception& e) {
68555       {
68556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68557       };
68558     } catch (...) {
68559       {
68560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68561       };
68562     }
68563   }
68564   jresult = new Dali::Actor((const Dali::Actor &)result);
68565   return jresult;
68566 }
68567
68568
68569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
68570   unsigned int jresult ;
68571   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68572   Dali::Actor arg2 ;
68573   Dali::Actor *argp2 ;
68574   Dali::Toolkit::ItemId result;
68575
68576   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68577   argp2 = (Dali::Actor *)jarg2;
68578   if (!argp2) {
68579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68580     return 0;
68581   }
68582   arg2 = *argp2;
68583   {
68584     try {
68585       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
68586     } catch (std::out_of_range& e) {
68587       {
68588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68589       };
68590     } catch (std::exception& e) {
68591       {
68592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68593       };
68594     } catch (...) {
68595       {
68596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68597       };
68598     }
68599   }
68600   jresult = result;
68601   return jresult;
68602 }
68603
68604
68605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
68606   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68607   Dali::Toolkit::Item arg2 ;
68608   float arg3 ;
68609   Dali::Toolkit::Item *argp2 ;
68610
68611   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68612   argp2 = (Dali::Toolkit::Item *)jarg2;
68613   if (!argp2) {
68614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
68615     return ;
68616   }
68617   arg2 = *argp2;
68618   arg3 = (float)jarg3;
68619   {
68620     try {
68621       (arg1)->InsertItem(arg2,arg3);
68622     } catch (std::out_of_range& e) {
68623       {
68624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68625       };
68626     } catch (std::exception& e) {
68627       {
68628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68629       };
68630     } catch (...) {
68631       {
68632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68633       };
68634     }
68635   }
68636 }
68637
68638
68639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
68640   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68641   Dali::Toolkit::ItemContainer *arg2 = 0 ;
68642   float arg3 ;
68643
68644   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68645   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
68646   if (!arg2) {
68647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
68648     return ;
68649   }
68650   arg3 = (float)jarg3;
68651   {
68652     try {
68653       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
68654     } catch (std::out_of_range& e) {
68655       {
68656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68657       };
68658     } catch (std::exception& e) {
68659       {
68660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68661       };
68662     } catch (...) {
68663       {
68664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68665       };
68666     }
68667   }
68668 }
68669
68670
68671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
68672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68673   Dali::Toolkit::ItemId arg2 ;
68674   float arg3 ;
68675
68676   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68677   arg2 = (Dali::Toolkit::ItemId)jarg2;
68678   arg3 = (float)jarg3;
68679   {
68680     try {
68681       (arg1)->RemoveItem(arg2,arg3);
68682     } catch (std::out_of_range& e) {
68683       {
68684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68685       };
68686     } catch (std::exception& e) {
68687       {
68688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68689       };
68690     } catch (...) {
68691       {
68692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68693       };
68694     }
68695   }
68696 }
68697
68698
68699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
68700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68701   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
68702   float arg3 ;
68703
68704   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68705   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
68706   if (!arg2) {
68707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
68708     return ;
68709   }
68710   arg3 = (float)jarg3;
68711   {
68712     try {
68713       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
68714     } catch (std::out_of_range& e) {
68715       {
68716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68717       };
68718     } catch (std::exception& e) {
68719       {
68720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68721       };
68722     } catch (...) {
68723       {
68724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68725       };
68726     }
68727   }
68728 }
68729
68730
68731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
68732   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68733   Dali::Toolkit::Item arg2 ;
68734   float arg3 ;
68735   Dali::Toolkit::Item *argp2 ;
68736
68737   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68738   argp2 = (Dali::Toolkit::Item *)jarg2;
68739   if (!argp2) {
68740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
68741     return ;
68742   }
68743   arg2 = *argp2;
68744   arg3 = (float)jarg3;
68745   {
68746     try {
68747       (arg1)->ReplaceItem(arg2,arg3);
68748     } catch (std::out_of_range& e) {
68749       {
68750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68751       };
68752     } catch (std::exception& e) {
68753       {
68754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68755       };
68756     } catch (...) {
68757       {
68758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68759       };
68760     }
68761   }
68762 }
68763
68764
68765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
68766   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68767   Dali::Toolkit::ItemContainer *arg2 = 0 ;
68768   float arg3 ;
68769
68770   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68771   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
68772   if (!arg2) {
68773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
68774     return ;
68775   }
68776   arg3 = (float)jarg3;
68777   {
68778     try {
68779       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
68780     } catch (std::out_of_range& e) {
68781       {
68782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68783       };
68784     } catch (std::exception& e) {
68785       {
68786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68787       };
68788     } catch (...) {
68789       {
68790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68791       };
68792     }
68793   }
68794 }
68795
68796
68797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
68798   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68799   Dali::Vector3 *arg2 = 0 ;
68800
68801   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68802   arg2 = (Dali::Vector3 *)jarg2;
68803   if (!arg2) {
68804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68805     return ;
68806   }
68807   {
68808     try {
68809       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
68810     } catch (std::out_of_range& e) {
68811       {
68812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68813       };
68814     } catch (std::exception& e) {
68815       {
68816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68817       };
68818     } catch (...) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68821       };
68822     }
68823   }
68824 }
68825
68826
68827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
68828   void * jresult ;
68829   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68830   Dali::Vector3 result;
68831
68832   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68833   {
68834     try {
68835       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
68836     } catch (std::out_of_range& e) {
68837       {
68838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (std::exception& e) {
68841       {
68842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68843       };
68844     } catch (...) {
68845       {
68846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68847       };
68848     }
68849   }
68850   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
68851   return jresult;
68852 }
68853
68854
68855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
68856   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68857   Dali::Vector3 *arg2 = 0 ;
68858
68859   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68860   arg2 = (Dali::Vector3 *)jarg2;
68861   if (!arg2) {
68862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68863     return ;
68864   }
68865   {
68866     try {
68867       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
68868     } catch (std::out_of_range& e) {
68869       {
68870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68871       };
68872     } catch (std::exception& e) {
68873       {
68874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68875       };
68876     } catch (...) {
68877       {
68878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68879       };
68880     }
68881   }
68882 }
68883
68884
68885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
68886   void * jresult ;
68887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68888   Dali::Vector3 result;
68889
68890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68891   {
68892     try {
68893       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
68894     } catch (std::out_of_range& e) {
68895       {
68896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68897       };
68898     } catch (std::exception& e) {
68899       {
68900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68901       };
68902     } catch (...) {
68903       {
68904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68905       };
68906     }
68907   }
68908   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
68909   return jresult;
68910 }
68911
68912
68913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
68914   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68915   Dali::Toolkit::ItemRange *arg2 = 0 ;
68916
68917   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68918   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68919   if (!arg2) {
68920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
68921     return ;
68922   }
68923   {
68924     try {
68925       (arg1)->GetItemsRange(*arg2);
68926     } catch (std::out_of_range& e) {
68927       {
68928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68929       };
68930     } catch (std::exception& e) {
68931       {
68932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68933       };
68934     } catch (...) {
68935       {
68936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68937       };
68938     }
68939   }
68940 }
68941
68942
68943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
68944   void * jresult ;
68945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68946   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
68947
68948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68949   {
68950     try {
68951       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
68952     } catch (std::out_of_range& e) {
68953       {
68954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68955       };
68956     } catch (std::exception& e) {
68957       {
68958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68959       };
68960     } catch (...) {
68961       {
68962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68963       };
68964     }
68965   }
68966   jresult = (void *)result;
68967   return jresult;
68968 }
68969
68970
68971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
68972   Dali::Vector3 *arg1 = 0 ;
68973   PropertyInputContainer *arg2 = 0 ;
68974
68975   arg1 = (Dali::Vector3 *)jarg1;
68976   if (!arg1) {
68977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68978     return ;
68979   }
68980   arg2 = (PropertyInputContainer *)jarg2;
68981   if (!arg2) {
68982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
68983     return ;
68984   }
68985   {
68986     try {
68987       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
68988     } catch (std::out_of_range& e) {
68989       {
68990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68991       };
68992     } catch (std::exception& e) {
68993       {
68994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68995       };
68996     } catch (...) {
68997       {
68998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68999       };
69000     }
69001   }
69002 }
69003
69004
69005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
69006   Dali::Vector3 *arg1 = 0 ;
69007   PropertyInputContainer *arg2 = 0 ;
69008
69009   arg1 = (Dali::Vector3 *)jarg1;
69010   if (!arg1) {
69011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69012     return ;
69013   }
69014   arg2 = (PropertyInputContainer *)jarg2;
69015   if (!arg2) {
69016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
69017     return ;
69018   }
69019   {
69020     try {
69021       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
69022     } catch (std::out_of_range& e) {
69023       {
69024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69025       };
69026     } catch (std::exception& e) {
69027       {
69028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69029       };
69030     } catch (...) {
69031       {
69032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69033       };
69034     }
69035   }
69036 }
69037
69038
69039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
69040   void * jresult ;
69041   Dali::Toolkit::ScrollViewEffect *result = 0 ;
69042
69043   {
69044     try {
69045       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
69046     } catch (std::out_of_range& e) {
69047       {
69048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69049       };
69050     } catch (std::exception& e) {
69051       {
69052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69053       };
69054     } catch (...) {
69055       {
69056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69057       };
69058     }
69059   }
69060   jresult = (void *)result;
69061   return jresult;
69062 }
69063
69064
69065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
69066   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
69067
69068   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
69069   {
69070     try {
69071       delete arg1;
69072     } catch (std::out_of_range& e) {
69073       {
69074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69075       };
69076     } catch (std::exception& e) {
69077       {
69078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69079       };
69080     } catch (...) {
69081       {
69082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69083       };
69084     }
69085   }
69086 }
69087
69088
69089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
69090   void * jresult ;
69091   Dali::Path arg1 ;
69092   Dali::Vector3 *arg2 = 0 ;
69093   Dali::Property::Index arg3 ;
69094   Dali::Vector3 *arg4 = 0 ;
69095   unsigned int arg5 ;
69096   Dali::Path *argp1 ;
69097   Dali::Toolkit::ScrollViewPagePathEffect result;
69098
69099   argp1 = (Dali::Path *)jarg1;
69100   if (!argp1) {
69101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
69102     return 0;
69103   }
69104   arg1 = *argp1;
69105   arg2 = (Dali::Vector3 *)jarg2;
69106   if (!arg2) {
69107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69108     return 0;
69109   }
69110   arg3 = (Dali::Property::Index)jarg3;
69111   arg4 = (Dali::Vector3 *)jarg4;
69112   if (!arg4) {
69113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69114     return 0;
69115   }
69116   arg5 = (unsigned int)jarg5;
69117   {
69118     try {
69119       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
69120     } catch (std::out_of_range& e) {
69121       {
69122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69123       };
69124     } catch (std::exception& e) {
69125       {
69126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69127       };
69128     } catch (...) {
69129       {
69130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69131       };
69132     }
69133   }
69134   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
69135   return jresult;
69136 }
69137
69138
69139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
69140   void * jresult ;
69141   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
69142
69143   {
69144     try {
69145       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
69146     } catch (std::out_of_range& e) {
69147       {
69148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69149       };
69150     } catch (std::exception& e) {
69151       {
69152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69153       };
69154     } catch (...) {
69155       {
69156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69157       };
69158     }
69159   }
69160   jresult = (void *)result;
69161   return jresult;
69162 }
69163
69164
69165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
69166   void * jresult ;
69167   Dali::BaseHandle arg1 ;
69168   Dali::BaseHandle *argp1 ;
69169   Dali::Toolkit::ScrollViewPagePathEffect result;
69170
69171   argp1 = (Dali::BaseHandle *)jarg1;
69172   if (!argp1) {
69173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69174     return 0;
69175   }
69176   arg1 = *argp1;
69177   {
69178     try {
69179       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
69180     } catch (std::out_of_range& e) {
69181       {
69182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69183       };
69184     } catch (std::exception& e) {
69185       {
69186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69187       };
69188     } catch (...) {
69189       {
69190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69191       };
69192     }
69193   }
69194   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
69195   return jresult;
69196 }
69197
69198
69199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
69200   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
69201   Dali::Actor arg2 ;
69202   unsigned int arg3 ;
69203   Dali::Actor *argp2 ;
69204
69205   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
69206   argp2 = (Dali::Actor *)jarg2;
69207   if (!argp2) {
69208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69209     return ;
69210   }
69211   arg2 = *argp2;
69212   arg3 = (unsigned int)jarg3;
69213   {
69214     try {
69215       (arg1)->ApplyToPage(arg2,arg3);
69216     } catch (std::out_of_range& e) {
69217       {
69218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69219       };
69220     } catch (std::exception& e) {
69221       {
69222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69223       };
69224     } catch (...) {
69225       {
69226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69227       };
69228     }
69229   }
69230 }
69231
69232
69233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
69234   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
69235
69236   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
69237   {
69238     try {
69239       delete arg1;
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69247       };
69248     } catch (...) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69251       };
69252     }
69253   }
69254 }
69255
69256
69257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
69258   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69259   Dali::Toolkit::ClampState arg2 ;
69260
69261   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69262   arg2 = (Dali::Toolkit::ClampState)jarg2;
69263   if (arg1) (arg1)->x = arg2;
69264 }
69265
69266
69267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
69268   int jresult ;
69269   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69270   Dali::Toolkit::ClampState result;
69271
69272   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69273   result = (Dali::Toolkit::ClampState) ((arg1)->x);
69274   jresult = (int)result;
69275   return jresult;
69276 }
69277
69278
69279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
69280   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69281   Dali::Toolkit::ClampState arg2 ;
69282
69283   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69284   arg2 = (Dali::Toolkit::ClampState)jarg2;
69285   if (arg1) (arg1)->y = arg2;
69286 }
69287
69288
69289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
69290   int jresult ;
69291   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69292   Dali::Toolkit::ClampState result;
69293
69294   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69295   result = (Dali::Toolkit::ClampState) ((arg1)->y);
69296   jresult = (int)result;
69297   return jresult;
69298 }
69299
69300
69301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
69302   void * jresult ;
69303   Dali::Toolkit::ClampState2D *result = 0 ;
69304
69305   {
69306     try {
69307       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
69308     } catch (std::out_of_range& e) {
69309       {
69310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69311       };
69312     } catch (std::exception& e) {
69313       {
69314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69315       };
69316     } catch (...) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69319       };
69320     }
69321   }
69322   jresult = (void *)result;
69323   return jresult;
69324 }
69325
69326
69327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
69328   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69329
69330   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69331   {
69332     try {
69333       delete arg1;
69334     } catch (std::out_of_range& e) {
69335       {
69336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69337       };
69338     } catch (std::exception& e) {
69339       {
69340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69341       };
69342     } catch (...) {
69343       {
69344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69345       };
69346     }
69347   }
69348 }
69349
69350
69351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
69352   void * jresult ;
69353   float arg1 ;
69354   float arg2 ;
69355   bool arg3 ;
69356   Dali::Toolkit::RulerDomain *result = 0 ;
69357
69358   arg1 = (float)jarg1;
69359   arg2 = (float)jarg2;
69360   arg3 = jarg3 ? true : false;
69361   {
69362     try {
69363       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
69364     } catch (std::out_of_range& e) {
69365       {
69366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69367       };
69368     } catch (std::exception& e) {
69369       {
69370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69371       };
69372     } catch (...) {
69373       {
69374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69375       };
69376     }
69377   }
69378   jresult = (void *)result;
69379   return jresult;
69380 }
69381
69382
69383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
69384   void * jresult ;
69385   float arg1 ;
69386   float arg2 ;
69387   Dali::Toolkit::RulerDomain *result = 0 ;
69388
69389   arg1 = (float)jarg1;
69390   arg2 = (float)jarg2;
69391   {
69392     try {
69393       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
69394     } catch (std::out_of_range& e) {
69395       {
69396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69397       };
69398     } catch (std::exception& e) {
69399       {
69400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69401       };
69402     } catch (...) {
69403       {
69404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69405       };
69406     }
69407   }
69408   jresult = (void *)result;
69409   return jresult;
69410 }
69411
69412
69413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
69414   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69415   float arg2 ;
69416
69417   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69418   arg2 = (float)jarg2;
69419   if (arg1) (arg1)->min = arg2;
69420 }
69421
69422
69423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
69424   float jresult ;
69425   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69426   float result;
69427
69428   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69429   result = (float) ((arg1)->min);
69430   jresult = result;
69431   return jresult;
69432 }
69433
69434
69435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
69436   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69437   float arg2 ;
69438
69439   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69440   arg2 = (float)jarg2;
69441   if (arg1) (arg1)->max = arg2;
69442 }
69443
69444
69445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
69446   float jresult ;
69447   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69448   float result;
69449
69450   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69451   result = (float) ((arg1)->max);
69452   jresult = result;
69453   return jresult;
69454 }
69455
69456
69457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
69458   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69459   bool arg2 ;
69460
69461   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69462   arg2 = jarg2 ? true : false;
69463   if (arg1) (arg1)->enabled = arg2;
69464 }
69465
69466
69467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
69468   unsigned int jresult ;
69469   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69470   bool result;
69471
69472   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69473   result = (bool) ((arg1)->enabled);
69474   jresult = result;
69475   return jresult;
69476 }
69477
69478
69479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
69480   float jresult ;
69481   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69482   float arg2 ;
69483   float arg3 ;
69484   float arg4 ;
69485   float result;
69486
69487   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69488   arg2 = (float)jarg2;
69489   arg3 = (float)jarg3;
69490   arg4 = (float)jarg4;
69491   {
69492     try {
69493       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
69494     } catch (std::out_of_range& e) {
69495       {
69496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69497       };
69498     } catch (std::exception& e) {
69499       {
69500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69501       };
69502     } catch (...) {
69503       {
69504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69505       };
69506     }
69507   }
69508   jresult = result;
69509   return jresult;
69510 }
69511
69512
69513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
69514   float jresult ;
69515   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69516   float arg2 ;
69517   float arg3 ;
69518   float result;
69519
69520   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69521   arg2 = (float)jarg2;
69522   arg3 = (float)jarg3;
69523   {
69524     try {
69525       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
69526     } catch (std::out_of_range& e) {
69527       {
69528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69529       };
69530     } catch (std::exception& e) {
69531       {
69532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69533       };
69534     } catch (...) {
69535       {
69536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69537       };
69538     }
69539   }
69540   jresult = result;
69541   return jresult;
69542 }
69543
69544
69545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
69546   float jresult ;
69547   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69548   float arg2 ;
69549   float result;
69550
69551   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69552   arg2 = (float)jarg2;
69553   {
69554     try {
69555       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
69556     } catch (std::out_of_range& e) {
69557       {
69558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69559       };
69560     } catch (std::exception& e) {
69561       {
69562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69563       };
69564     } catch (...) {
69565       {
69566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69567       };
69568     }
69569   }
69570   jresult = result;
69571   return jresult;
69572 }
69573
69574
69575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
69576   float jresult ;
69577   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69578   float arg2 ;
69579   float arg3 ;
69580   float arg4 ;
69581   Dali::Toolkit::ClampState *arg5 = 0 ;
69582   float result;
69583
69584   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69585   arg2 = (float)jarg2;
69586   arg3 = (float)jarg3;
69587   arg4 = (float)jarg4;
69588   arg5 = (Dali::Toolkit::ClampState *)jarg5;
69589   if (!arg5) {
69590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
69591     return 0;
69592   }
69593   {
69594     try {
69595       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
69596     } catch (std::out_of_range& e) {
69597       {
69598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69599       };
69600     } catch (std::exception& e) {
69601       {
69602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69603       };
69604     } catch (...) {
69605       {
69606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69607       };
69608     }
69609   }
69610   jresult = result;
69611   return jresult;
69612 }
69613
69614
69615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
69616   float jresult ;
69617   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69618   float result;
69619
69620   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69621   {
69622     try {
69623       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
69624     } catch (std::out_of_range& e) {
69625       {
69626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69627       };
69628     } catch (std::exception& e) {
69629       {
69630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69631       };
69632     } catch (...) {
69633       {
69634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69635       };
69636     }
69637   }
69638   jresult = result;
69639   return jresult;
69640 }
69641
69642
69643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
69644   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69645
69646   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69647   {
69648     try {
69649       delete arg1;
69650     } catch (std::out_of_range& e) {
69651       {
69652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69653       };
69654     } catch (std::exception& e) {
69655       {
69656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69657       };
69658     } catch (...) {
69659       {
69660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69661       };
69662     }
69663   }
69664 }
69665
69666
69667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
69668   float jresult ;
69669   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69670   float arg2 ;
69671   float arg3 ;
69672   float result;
69673
69674   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69675   arg2 = (float)jarg2;
69676   arg3 = (float)jarg3;
69677   {
69678     try {
69679       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
69680     } catch (std::out_of_range& e) {
69681       {
69682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69683       };
69684     } catch (std::exception& e) {
69685       {
69686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69687       };
69688     } catch (...) {
69689       {
69690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69691       };
69692     }
69693   }
69694   jresult = result;
69695   return jresult;
69696 }
69697
69698
69699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
69700   float jresult ;
69701   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69702   float arg2 ;
69703   float result;
69704
69705   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69706   arg2 = (float)jarg2;
69707   {
69708     try {
69709       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
69710     } catch (std::out_of_range& e) {
69711       {
69712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69713       };
69714     } catch (std::exception& e) {
69715       {
69716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69717       };
69718     } catch (...) {
69719       {
69720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69721       };
69722     }
69723   }
69724   jresult = result;
69725   return jresult;
69726 }
69727
69728
69729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
69730   float jresult ;
69731   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69732   unsigned int arg2 ;
69733   unsigned int *arg3 = 0 ;
69734   bool arg4 ;
69735   float result;
69736
69737   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69738   arg2 = (unsigned int)jarg2;
69739   arg3 = (unsigned int *)jarg3;
69740   arg4 = jarg4 ? true : false;
69741   {
69742     try {
69743       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
69744     } catch (std::out_of_range& e) {
69745       {
69746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69747       };
69748     } catch (std::exception& e) {
69749       {
69750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69751       };
69752     } catch (...) {
69753       {
69754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69755       };
69756     }
69757   }
69758   jresult = result;
69759   return jresult;
69760 }
69761
69762
69763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
69764   unsigned int jresult ;
69765   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69766   float arg2 ;
69767   bool arg3 ;
69768   unsigned int result;
69769
69770   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69771   arg2 = (float)jarg2;
69772   arg3 = jarg3 ? true : false;
69773   {
69774     try {
69775       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
69776     } catch (std::out_of_range& e) {
69777       {
69778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69779       };
69780     } catch (std::exception& e) {
69781       {
69782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69783       };
69784     } catch (...) {
69785       {
69786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69787       };
69788     }
69789   }
69790   jresult = result;
69791   return jresult;
69792 }
69793
69794
69795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
69796   unsigned int jresult ;
69797   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69798   unsigned int result;
69799
69800   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69801   {
69802     try {
69803       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
69804     } catch (std::out_of_range& e) {
69805       {
69806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69807       };
69808     } catch (std::exception& e) {
69809       {
69810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (...) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69815       };
69816     }
69817   }
69818   jresult = result;
69819   return jresult;
69820 }
69821
69822
69823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
69824   int jresult ;
69825   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69826   Dali::Toolkit::Ruler::RulerType result;
69827
69828   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69829   {
69830     try {
69831       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
69832     } catch (std::out_of_range& e) {
69833       {
69834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69835       };
69836     } catch (std::exception& e) {
69837       {
69838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69839       };
69840     } catch (...) {
69841       {
69842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69843       };
69844     }
69845   }
69846   jresult = (int)result;
69847   return jresult;
69848 }
69849
69850
69851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
69852   unsigned int jresult ;
69853   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69854   bool result;
69855
69856   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69857   {
69858     try {
69859       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
69860     } catch (std::out_of_range& e) {
69861       {
69862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69863       };
69864     } catch (std::exception& e) {
69865       {
69866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69867       };
69868     } catch (...) {
69869       {
69870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69871       };
69872     }
69873   }
69874   jresult = result;
69875   return jresult;
69876 }
69877
69878
69879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
69880   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69881
69882   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69883   {
69884     try {
69885       (arg1)->Enable();
69886     } catch (std::out_of_range& e) {
69887       {
69888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69889       };
69890     } catch (std::exception& e) {
69891       {
69892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69893       };
69894     } catch (...) {
69895       {
69896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69897       };
69898     }
69899   }
69900 }
69901
69902
69903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
69904   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69905
69906   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69907   {
69908     try {
69909       (arg1)->Disable();
69910     } catch (std::out_of_range& e) {
69911       {
69912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69913       };
69914     } catch (std::exception& e) {
69915       {
69916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69917       };
69918     } catch (...) {
69919       {
69920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69921       };
69922     }
69923   }
69924 }
69925
69926
69927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
69928   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69929   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
69930   Dali::Toolkit::RulerDomain *argp2 ;
69931
69932   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69933   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
69934   if (!argp2) {
69935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
69936     return ;
69937   }
69938   arg2 = *argp2;
69939   {
69940     try {
69941       (arg1)->SetDomain(arg2);
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69953       };
69954     }
69955   }
69956 }
69957
69958
69959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
69960   void * jresult ;
69961   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69962   Dali::Toolkit::RulerDomain *result = 0 ;
69963
69964   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69965   {
69966     try {
69967       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
69968     } catch (std::out_of_range& e) {
69969       {
69970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69971       };
69972     } catch (std::exception& e) {
69973       {
69974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69975       };
69976     } catch (...) {
69977       {
69978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69979       };
69980     }
69981   }
69982   jresult = (void *)result;
69983   return jresult;
69984 }
69985
69986
69987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
69988   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69989
69990   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69991   {
69992     try {
69993       (arg1)->DisableDomain();
69994     } catch (std::out_of_range& e) {
69995       {
69996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69997       };
69998     } catch (std::exception& e) {
69999       {
70000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70001       };
70002     } catch (...) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70005       };
70006     }
70007   }
70008 }
70009
70010
70011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
70012   float jresult ;
70013   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70014   float arg2 ;
70015   float arg3 ;
70016   float arg4 ;
70017   float result;
70018
70019   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70020   arg2 = (float)jarg2;
70021   arg3 = (float)jarg3;
70022   arg4 = (float)jarg4;
70023   {
70024     try {
70025       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
70026     } catch (std::out_of_range& e) {
70027       {
70028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70029       };
70030     } catch (std::exception& e) {
70031       {
70032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70033       };
70034     } catch (...) {
70035       {
70036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70037       };
70038     }
70039   }
70040   jresult = result;
70041   return jresult;
70042 }
70043
70044
70045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
70046   float jresult ;
70047   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70048   float arg2 ;
70049   float arg3 ;
70050   float result;
70051
70052   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70053   arg2 = (float)jarg2;
70054   arg3 = (float)jarg3;
70055   {
70056     try {
70057       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
70058     } catch (std::out_of_range& e) {
70059       {
70060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70061       };
70062     } catch (std::exception& e) {
70063       {
70064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70065       };
70066     } catch (...) {
70067       {
70068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70069       };
70070     }
70071   }
70072   jresult = result;
70073   return jresult;
70074 }
70075
70076
70077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
70078   float jresult ;
70079   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70080   float arg2 ;
70081   float result;
70082
70083   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70084   arg2 = (float)jarg2;
70085   {
70086     try {
70087       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
70088     } catch (std::out_of_range& e) {
70089       {
70090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70091       };
70092     } catch (std::exception& e) {
70093       {
70094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70095       };
70096     } catch (...) {
70097       {
70098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70099       };
70100     }
70101   }
70102   jresult = result;
70103   return jresult;
70104 }
70105
70106
70107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
70108   float jresult ;
70109   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70110   float arg2 ;
70111   float arg3 ;
70112   float arg4 ;
70113   Dali::Toolkit::ClampState *arg5 = 0 ;
70114   float result;
70115
70116   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70117   arg2 = (float)jarg2;
70118   arg3 = (float)jarg3;
70119   arg4 = (float)jarg4;
70120   arg5 = (Dali::Toolkit::ClampState *)jarg5;
70121   if (!arg5) {
70122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
70123     return 0;
70124   }
70125   {
70126     try {
70127       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
70128     } catch (std::out_of_range& e) {
70129       {
70130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70131       };
70132     } catch (std::exception& e) {
70133       {
70134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70135       };
70136     } catch (...) {
70137       {
70138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70139       };
70140     }
70141   }
70142   jresult = result;
70143   return jresult;
70144 }
70145
70146
70147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
70148   float jresult ;
70149   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70150   float arg2 ;
70151   float arg3 ;
70152   float arg4 ;
70153   float arg5 ;
70154   float result;
70155
70156   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70157   arg2 = (float)jarg2;
70158   arg3 = (float)jarg3;
70159   arg4 = (float)jarg4;
70160   arg5 = (float)jarg5;
70161   {
70162     try {
70163       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
70164     } catch (std::out_of_range& e) {
70165       {
70166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70167       };
70168     } catch (std::exception& e) {
70169       {
70170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70171       };
70172     } catch (...) {
70173       {
70174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70175       };
70176     }
70177   }
70178   jresult = result;
70179   return jresult;
70180 }
70181
70182
70183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
70184   float jresult ;
70185   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70186   float arg2 ;
70187   float arg3 ;
70188   float arg4 ;
70189   float result;
70190
70191   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70192   arg2 = (float)jarg2;
70193   arg3 = (float)jarg3;
70194   arg4 = (float)jarg4;
70195   {
70196     try {
70197       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
70198     } catch (std::out_of_range& e) {
70199       {
70200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70201       };
70202     } catch (std::exception& e) {
70203       {
70204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70205       };
70206     } catch (...) {
70207       {
70208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70209       };
70210     }
70211   }
70212   jresult = result;
70213   return jresult;
70214 }
70215
70216
70217 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
70218   float jresult ;
70219   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70220   float arg2 ;
70221   float arg3 ;
70222   float result;
70223
70224   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70225   arg2 = (float)jarg2;
70226   arg3 = (float)jarg3;
70227   {
70228     try {
70229       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
70230     } catch (std::out_of_range& e) {
70231       {
70232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70233       };
70234     } catch (std::exception& e) {
70235       {
70236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70237       };
70238     } catch (...) {
70239       {
70240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70241       };
70242     }
70243   }
70244   jresult = result;
70245   return jresult;
70246 }
70247
70248
70249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
70250   float jresult ;
70251   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70252   float arg2 ;
70253   float result;
70254
70255   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70256   arg2 = (float)jarg2;
70257   {
70258     try {
70259       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
70260     } catch (std::out_of_range& e) {
70261       {
70262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70263       };
70264     } catch (std::exception& e) {
70265       {
70266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70267       };
70268     } catch (...) {
70269       {
70270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70271       };
70272     }
70273   }
70274   jresult = result;
70275   return jresult;
70276 }
70277
70278
70279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
70280   float jresult ;
70281   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70282   float arg2 ;
70283   float arg3 ;
70284   float arg4 ;
70285   float arg5 ;
70286   Dali::Toolkit::ClampState *arg6 = 0 ;
70287   float result;
70288
70289   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70290   arg2 = (float)jarg2;
70291   arg3 = (float)jarg3;
70292   arg4 = (float)jarg4;
70293   arg5 = (float)jarg5;
70294   arg6 = (Dali::Toolkit::ClampState *)jarg6;
70295   if (!arg6) {
70296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
70297     return 0;
70298   }
70299   {
70300     try {
70301       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
70302     } catch (std::out_of_range& e) {
70303       {
70304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70305       };
70306     } catch (std::exception& e) {
70307       {
70308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70309       };
70310     } catch (...) {
70311       {
70312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70313       };
70314     }
70315   }
70316   jresult = result;
70317   return jresult;
70318 }
70319
70320
70321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
70322   void * jresult ;
70323   Dali::Toolkit::DefaultRuler *result = 0 ;
70324
70325   {
70326     try {
70327       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
70328     } catch (std::out_of_range& e) {
70329       {
70330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70331       };
70332     } catch (std::exception& e) {
70333       {
70334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70335       };
70336     } catch (...) {
70337       {
70338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70339       };
70340     }
70341   }
70342   jresult = (void *)result;
70343   return jresult;
70344 }
70345
70346
70347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
70348   float jresult ;
70349   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70350   float arg2 ;
70351   float arg3 ;
70352   float result;
70353
70354   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70355   arg2 = (float)jarg2;
70356   arg3 = (float)jarg3;
70357   {
70358     try {
70359       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
70360     } catch (std::out_of_range& e) {
70361       {
70362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70363       };
70364     } catch (std::exception& e) {
70365       {
70366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70367       };
70368     } catch (...) {
70369       {
70370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70371       };
70372     }
70373   }
70374   jresult = result;
70375   return jresult;
70376 }
70377
70378
70379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
70380   float jresult ;
70381   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70382   unsigned int arg2 ;
70383   unsigned int *arg3 = 0 ;
70384   bool arg4 ;
70385   float result;
70386
70387   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70388   arg2 = (unsigned int)jarg2;
70389   arg3 = (unsigned int *)jarg3;
70390   arg4 = jarg4 ? true : false;
70391   {
70392     try {
70393       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
70394     } catch (std::out_of_range& e) {
70395       {
70396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70397       };
70398     } catch (std::exception& e) {
70399       {
70400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70401       };
70402     } catch (...) {
70403       {
70404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70405       };
70406     }
70407   }
70408   jresult = result;
70409   return jresult;
70410 }
70411
70412
70413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
70414   unsigned int jresult ;
70415   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70416   float arg2 ;
70417   bool arg3 ;
70418   unsigned int result;
70419
70420   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70421   arg2 = (float)jarg2;
70422   arg3 = jarg3 ? true : false;
70423   {
70424     try {
70425       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
70426     } catch (std::out_of_range& e) {
70427       {
70428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70429       };
70430     } catch (std::exception& e) {
70431       {
70432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70433       };
70434     } catch (...) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70437       };
70438     }
70439   }
70440   jresult = result;
70441   return jresult;
70442 }
70443
70444
70445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
70446   unsigned int jresult ;
70447   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70448   unsigned int result;
70449
70450   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70451   {
70452     try {
70453       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
70454     } catch (std::out_of_range& e) {
70455       {
70456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70457       };
70458     } catch (std::exception& e) {
70459       {
70460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70461       };
70462     } catch (...) {
70463       {
70464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70465       };
70466     }
70467   }
70468   jresult = result;
70469   return jresult;
70470 }
70471
70472
70473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
70474   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70475
70476   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70477   {
70478     try {
70479       delete arg1;
70480     } catch (std::out_of_range& e) {
70481       {
70482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70483       };
70484     } catch (std::exception& e) {
70485       {
70486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70487       };
70488     } catch (...) {
70489       {
70490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70491       };
70492     }
70493   }
70494 }
70495
70496
70497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
70498   void * jresult ;
70499   float arg1 ;
70500   Dali::Toolkit::FixedRuler *result = 0 ;
70501
70502   arg1 = (float)jarg1;
70503   {
70504     try {
70505       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
70506     } catch (std::out_of_range& e) {
70507       {
70508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70509       };
70510     } catch (std::exception& e) {
70511       {
70512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70513       };
70514     } catch (...) {
70515       {
70516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70517       };
70518     }
70519   }
70520   jresult = (void *)result;
70521   return jresult;
70522 }
70523
70524
70525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
70526   void * jresult ;
70527   Dali::Toolkit::FixedRuler *result = 0 ;
70528
70529   {
70530     try {
70531       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
70532     } catch (std::out_of_range& e) {
70533       {
70534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70535       };
70536     } catch (std::exception& e) {
70537       {
70538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70539       };
70540     } catch (...) {
70541       {
70542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70543       };
70544     }
70545   }
70546   jresult = (void *)result;
70547   return jresult;
70548 }
70549
70550
70551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
70552   float jresult ;
70553   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70554   float arg2 ;
70555   float arg3 ;
70556   float result;
70557
70558   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70559   arg2 = (float)jarg2;
70560   arg3 = (float)jarg3;
70561   {
70562     try {
70563       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
70564     } catch (std::out_of_range& e) {
70565       {
70566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70567       };
70568     } catch (std::exception& e) {
70569       {
70570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70571       };
70572     } catch (...) {
70573       {
70574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70575       };
70576     }
70577   }
70578   jresult = result;
70579   return jresult;
70580 }
70581
70582
70583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
70584   float jresult ;
70585   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70586   unsigned int arg2 ;
70587   unsigned int *arg3 = 0 ;
70588   bool arg4 ;
70589   float result;
70590
70591   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70592   arg2 = (unsigned int)jarg2;
70593   arg3 = (unsigned int *)jarg3;
70594   arg4 = jarg4 ? true : false;
70595   {
70596     try {
70597       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
70598     } catch (std::out_of_range& e) {
70599       {
70600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70601       };
70602     } catch (std::exception& e) {
70603       {
70604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70609       };
70610     }
70611   }
70612   jresult = result;
70613   return jresult;
70614 }
70615
70616
70617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
70618   unsigned int jresult ;
70619   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70620   float arg2 ;
70621   bool arg3 ;
70622   unsigned int result;
70623
70624   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70625   arg2 = (float)jarg2;
70626   arg3 = jarg3 ? true : false;
70627   {
70628     try {
70629       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
70630     } catch (std::out_of_range& e) {
70631       {
70632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70633       };
70634     } catch (std::exception& e) {
70635       {
70636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70637       };
70638     } catch (...) {
70639       {
70640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70641       };
70642     }
70643   }
70644   jresult = result;
70645   return jresult;
70646 }
70647
70648
70649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
70650   unsigned int jresult ;
70651   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70652   unsigned int result;
70653
70654   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70655   {
70656     try {
70657       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
70658     } catch (std::out_of_range& e) {
70659       {
70660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70661       };
70662     } catch (std::exception& e) {
70663       {
70664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70665       };
70666     } catch (...) {
70667       {
70668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70669       };
70670     }
70671   }
70672   jresult = result;
70673   return jresult;
70674 }
70675
70676
70677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
70678   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70679
70680   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70681   {
70682     try {
70683       delete arg1;
70684     } catch (std::out_of_range& e) {
70685       {
70686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70687       };
70688     } catch (std::exception& e) {
70689       {
70690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70691       };
70692     } catch (...) {
70693       {
70694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70695       };
70696     }
70697   }
70698 }
70699
70700
70701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
70702   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70703   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
70704
70705   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70706   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
70707   if (arg1) (arg1)->scale = *arg2;
70708 }
70709
70710
70711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
70712   void * jresult ;
70713   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70714   Dali::Toolkit::ClampState2D *result = 0 ;
70715
70716   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70717   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
70718   jresult = (void *)result;
70719   return jresult;
70720 }
70721
70722
70723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
70724   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70725   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
70726
70727   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70728   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
70729   if (arg1) (arg1)->position = *arg2;
70730 }
70731
70732
70733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
70734   void * jresult ;
70735   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70736   Dali::Toolkit::ClampState2D *result = 0 ;
70737
70738   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70739   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
70740   jresult = (void *)result;
70741   return jresult;
70742 }
70743
70744
70745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
70746   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70747   Dali::Toolkit::ClampState arg2 ;
70748
70749   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70750   arg2 = (Dali::Toolkit::ClampState)jarg2;
70751   if (arg1) (arg1)->rotation = arg2;
70752 }
70753
70754
70755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
70756   int jresult ;
70757   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70758   Dali::Toolkit::ClampState result;
70759
70760   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70761   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
70762   jresult = (int)result;
70763   return jresult;
70764 }
70765
70766
70767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
70768   void * jresult ;
70769   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
70770
70771   {
70772     try {
70773       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
70774     } catch (std::out_of_range& e) {
70775       {
70776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70777       };
70778     } catch (std::exception& e) {
70779       {
70780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70781       };
70782     } catch (...) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70785       };
70786     }
70787   }
70788   jresult = (void *)result;
70789   return jresult;
70790 }
70791
70792
70793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
70794   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70795
70796   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70797   {
70798     try {
70799       delete arg1;
70800     } catch (std::out_of_range& e) {
70801       {
70802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70803       };
70804     } catch (std::exception& e) {
70805       {
70806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70807       };
70808     } catch (...) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70811       };
70812     }
70813   }
70814 }
70815
70816
70817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
70818   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70819   Dali::Toolkit::SnapType arg2 ;
70820
70821   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70822   arg2 = (Dali::Toolkit::SnapType)jarg2;
70823   if (arg1) (arg1)->type = arg2;
70824 }
70825
70826
70827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
70828   int jresult ;
70829   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70830   Dali::Toolkit::SnapType result;
70831
70832   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70833   result = (Dali::Toolkit::SnapType) ((arg1)->type);
70834   jresult = (int)result;
70835   return jresult;
70836 }
70837
70838
70839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
70840   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70841   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
70842
70843   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70844   arg2 = (Dali::Vector2 *)jarg2;
70845   if (arg1) (arg1)->position = *arg2;
70846 }
70847
70848
70849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
70850   void * jresult ;
70851   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70852   Dali::Vector2 *result = 0 ;
70853
70854   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70855   result = (Dali::Vector2 *)& ((arg1)->position);
70856   jresult = (void *)result;
70857   return jresult;
70858 }
70859
70860
70861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
70862   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70863   float arg2 ;
70864
70865   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70866   arg2 = (float)jarg2;
70867   if (arg1) (arg1)->duration = arg2;
70868 }
70869
70870
70871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
70872   float jresult ;
70873   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70874   float result;
70875
70876   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70877   result = (float) ((arg1)->duration);
70878   jresult = result;
70879   return jresult;
70880 }
70881
70882
70883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
70884   void * jresult ;
70885   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
70886
70887   {
70888     try {
70889       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
70890     } catch (std::out_of_range& e) {
70891       {
70892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70893       };
70894     } catch (std::exception& e) {
70895       {
70896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70897       };
70898     } catch (...) {
70899       {
70900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70901       };
70902     }
70903   }
70904   jresult = (void *)result;
70905   return jresult;
70906 }
70907
70908
70909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
70910   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70911
70912   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70913   {
70914     try {
70915       delete arg1;
70916     } catch (std::out_of_range& e) {
70917       {
70918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70919       };
70920     } catch (std::exception& e) {
70921       {
70922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70923       };
70924     } catch (...) {
70925       {
70926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70927       };
70928     }
70929   }
70930 }
70931
70932
70933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
70934   int jresult ;
70935   int result;
70936
70937   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
70938   jresult = (int)result;
70939   return jresult;
70940 }
70941
70942
70943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
70944   int jresult ;
70945   int result;
70946
70947   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
70948   jresult = (int)result;
70949   return jresult;
70950 }
70951
70952
70953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
70954   int jresult ;
70955   int result;
70956
70957   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
70958   jresult = (int)result;
70959   return jresult;
70960 }
70961
70962
70963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70964   int jresult ;
70965   int result;
70966
70967   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70968   jresult = (int)result;
70969   return jresult;
70970 }
70971
70972
70973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
70974   int jresult ;
70975   int result;
70976
70977   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
70978   jresult = (int)result;
70979   return jresult;
70980 }
70981
70982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
70983   int jresult ;
70984   int result;
70985
70986   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
70987   jresult = (int)result;
70988   return jresult;
70989 }
70990
70991
70992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
70993   int jresult ;
70994   int result;
70995
70996   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
70997   jresult = (int)result;
70998   return jresult;
70999 }
71000
71001
71002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
71003   int jresult ;
71004   int result;
71005
71006   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
71007   jresult = (int)result;
71008   return jresult;
71009 }
71010
71011
71012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
71013   int jresult ;
71014   int result;
71015
71016   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
71017   jresult = (int)result;
71018   return jresult;
71019 }
71020
71021
71022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
71023   int jresult ;
71024   int result;
71025
71026   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
71027   jresult = (int)result;
71028   return jresult;
71029 }
71030
71031
71032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
71033   int jresult ;
71034   int result;
71035
71036   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
71037   jresult = (int)result;
71038   return jresult;
71039 }
71040
71041
71042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
71043   int jresult ;
71044   int result;
71045
71046   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
71047   jresult = (int)result;
71048   return jresult;
71049 }
71050
71051
71052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
71053   int jresult ;
71054   int result;
71055
71056   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
71057   jresult = (int)result;
71058   return jresult;
71059 }
71060
71061
71062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
71063   int jresult ;
71064   int result;
71065
71066   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
71067   jresult = (int)result;
71068   return jresult;
71069 }
71070
71071
71072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
71073   int jresult ;
71074   int result;
71075
71076   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
71077   jresult = (int)result;
71078   return jresult;
71079 }
71080
71081
71082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
71083   int jresult ;
71084   int result;
71085
71086   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
71087   jresult = (int)result;
71088   return jresult;
71089 }
71090
71091
71092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
71093   int jresult ;
71094   int result;
71095
71096   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
71097   jresult = (int)result;
71098   return jresult;
71099 }
71100
71101
71102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
71103   int jresult ;
71104   int result;
71105
71106   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
71107   jresult = (int)result;
71108   return jresult;
71109 }
71110
71111
71112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
71113   int jresult ;
71114   int result;
71115
71116   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
71117   jresult = (int)result;
71118   return jresult;
71119 }
71120
71121
71122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
71123   int jresult ;
71124   int result;
71125
71126   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
71127   jresult = (int)result;
71128   return jresult;
71129 }
71130
71131
71132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
71133   int jresult ;
71134   int result;
71135
71136   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
71137   jresult = (int)result;
71138   return jresult;
71139 }
71140
71141
71142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
71143   int jresult ;
71144   int result;
71145
71146   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
71147   jresult = (int)result;
71148   return jresult;
71149 }
71150
71151
71152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
71153   int jresult ;
71154   int result;
71155
71156   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
71157   jresult = (int)result;
71158   return jresult;
71159 }
71160
71161
71162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
71163   int jresult ;
71164   int result;
71165
71166   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
71167   jresult = (int)result;
71168   return jresult;
71169 }
71170
71171
71172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
71173   int jresult ;
71174   int result;
71175
71176   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
71177   jresult = (int)result;
71178   return jresult;
71179 }
71180
71181
71182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
71183   int jresult ;
71184   int result;
71185
71186   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
71187   jresult = (int)result;
71188   return jresult;
71189 }
71190
71191
71192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
71193   void * jresult ;
71194   Dali::Toolkit::ScrollView::Property *result = 0 ;
71195
71196   {
71197     try {
71198       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
71199     } catch (std::out_of_range& e) {
71200       {
71201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71202       };
71203     } catch (std::exception& e) {
71204       {
71205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71206       };
71207     } catch (...) {
71208       {
71209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71210       };
71211     }
71212   }
71213   jresult = (void *)result;
71214   return jresult;
71215 }
71216
71217
71218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
71219   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
71220
71221   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
71222   {
71223     try {
71224       delete arg1;
71225     } catch (std::out_of_range& e) {
71226       {
71227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71228       };
71229     } catch (std::exception& e) {
71230       {
71231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71232       };
71233     } catch (...) {
71234       {
71235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71236       };
71237     }
71238   }
71239 }
71240
71241
71242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
71243   void * jresult ;
71244   Dali::Toolkit::ScrollView *result = 0 ;
71245
71246   {
71247     try {
71248       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
71249     } catch (std::out_of_range& e) {
71250       {
71251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71252       };
71253     } catch (std::exception& e) {
71254       {
71255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71256       };
71257     } catch (...) {
71258       {
71259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71260       };
71261     }
71262   }
71263   jresult = (void *)result;
71264   return jresult;
71265 }
71266
71267
71268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
71269   void * jresult ;
71270   Dali::Toolkit::ScrollView *arg1 = 0 ;
71271   Dali::Toolkit::ScrollView *result = 0 ;
71272
71273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71274   if (!arg1) {
71275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
71276     return 0;
71277   }
71278   {
71279     try {
71280       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
71281     } catch (std::out_of_range& e) {
71282       {
71283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71284       };
71285     } catch (std::exception& e) {
71286       {
71287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71288       };
71289     } catch (...) {
71290       {
71291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71292       };
71293     }
71294   }
71295   jresult = (void *)result;
71296   return jresult;
71297 }
71298
71299
71300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
71301   void * jresult ;
71302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71303   Dali::Toolkit::ScrollView *arg2 = 0 ;
71304   Dali::Toolkit::ScrollView *result = 0 ;
71305
71306   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71307   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
71308   if (!arg2) {
71309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
71310     return 0;
71311   }
71312   {
71313     try {
71314       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
71315     } catch (std::out_of_range& e) {
71316       {
71317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71318       };
71319     } catch (std::exception& e) {
71320       {
71321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71322       };
71323     } catch (...) {
71324       {
71325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71326       };
71327     }
71328   }
71329   jresult = (void *)result;
71330   return jresult;
71331 }
71332
71333
71334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
71335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71336
71337   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71338   {
71339     try {
71340       delete arg1;
71341     } catch (std::out_of_range& e) {
71342       {
71343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71344       };
71345     } catch (std::exception& e) {
71346       {
71347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71348       };
71349     } catch (...) {
71350       {
71351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71352       };
71353     }
71354   }
71355 }
71356
71357
71358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
71359   void * jresult ;
71360   Dali::Toolkit::ScrollView result;
71361
71362   {
71363     try {
71364       result = Dali::Toolkit::ScrollView::New();
71365     } catch (std::out_of_range& e) {
71366       {
71367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71368       };
71369     } catch (std::exception& e) {
71370       {
71371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71372       };
71373     } catch (...) {
71374       {
71375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71376       };
71377     }
71378   }
71379   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
71380   return jresult;
71381 }
71382
71383
71384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
71385   void * jresult ;
71386   Dali::BaseHandle arg1 ;
71387   Dali::BaseHandle *argp1 ;
71388   Dali::Toolkit::ScrollView result;
71389
71390   argp1 = (Dali::BaseHandle *)jarg1;
71391   if (!argp1) {
71392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71393     return 0;
71394   }
71395   arg1 = *argp1;
71396   {
71397     try {
71398       result = Dali::Toolkit::ScrollView::DownCast(arg1);
71399     } catch (std::out_of_range& e) {
71400       {
71401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71402       };
71403     } catch (std::exception& e) {
71404       {
71405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71406       };
71407     } catch (...) {
71408       {
71409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71410       };
71411     }
71412   }
71413   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
71414   return jresult;
71415 }
71416
71417
71418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
71419   void * jresult ;
71420   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71421   Dali::AlphaFunction result;
71422
71423   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71424   {
71425     try {
71426       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
71427     } catch (std::out_of_range& e) {
71428       {
71429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71430       };
71431     } catch (std::exception& e) {
71432       {
71433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71438       };
71439     }
71440   }
71441   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
71442   return jresult;
71443 }
71444
71445
71446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
71447   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71448   Dali::AlphaFunction arg2 ;
71449   Dali::AlphaFunction *argp2 ;
71450
71451   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71452   argp2 = (Dali::AlphaFunction *)jarg2;
71453   if (!argp2) {
71454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71455     return ;
71456   }
71457   arg2 = *argp2;
71458   {
71459     try {
71460       (arg1)->SetScrollSnapAlphaFunction(arg2);
71461     } catch (std::out_of_range& e) {
71462       {
71463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71464       };
71465     } catch (std::exception& e) {
71466       {
71467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71468       };
71469     } catch (...) {
71470       {
71471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71472       };
71473     }
71474   }
71475 }
71476
71477
71478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
71479   void * jresult ;
71480   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71481   Dali::AlphaFunction result;
71482
71483   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71484   {
71485     try {
71486       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
71487     } catch (std::out_of_range& e) {
71488       {
71489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71490       };
71491     } catch (std::exception& e) {
71492       {
71493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71494       };
71495     } catch (...) {
71496       {
71497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71498       };
71499     }
71500   }
71501   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
71502   return jresult;
71503 }
71504
71505
71506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
71507   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71508   Dali::AlphaFunction arg2 ;
71509   Dali::AlphaFunction *argp2 ;
71510
71511   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71512   argp2 = (Dali::AlphaFunction *)jarg2;
71513   if (!argp2) {
71514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71515     return ;
71516   }
71517   arg2 = *argp2;
71518   {
71519     try {
71520       (arg1)->SetScrollFlickAlphaFunction(arg2);
71521     } catch (std::out_of_range& e) {
71522       {
71523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71524       };
71525     } catch (std::exception& e) {
71526       {
71527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71528       };
71529     } catch (...) {
71530       {
71531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71532       };
71533     }
71534   }
71535 }
71536
71537
71538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
71539   float jresult ;
71540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71541   float result;
71542
71543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71544   {
71545     try {
71546       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
71547     } catch (std::out_of_range& e) {
71548       {
71549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71550       };
71551     } catch (std::exception& e) {
71552       {
71553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71554       };
71555     } catch (...) {
71556       {
71557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71558       };
71559     }
71560   }
71561   jresult = result;
71562   return jresult;
71563 }
71564
71565
71566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
71567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71568   float arg2 ;
71569
71570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71571   arg2 = (float)jarg2;
71572   {
71573     try {
71574       (arg1)->SetScrollSnapDuration(arg2);
71575     } catch (std::out_of_range& e) {
71576       {
71577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71578       };
71579     } catch (std::exception& e) {
71580       {
71581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71582       };
71583     } catch (...) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71586       };
71587     }
71588   }
71589 }
71590
71591
71592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
71593   float jresult ;
71594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71595   float result;
71596
71597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71598   {
71599     try {
71600       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
71601     } catch (std::out_of_range& e) {
71602       {
71603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71604       };
71605     } catch (std::exception& e) {
71606       {
71607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71608       };
71609     } catch (...) {
71610       {
71611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71612       };
71613     }
71614   }
71615   jresult = result;
71616   return jresult;
71617 }
71618
71619
71620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
71621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71622   float arg2 ;
71623
71624   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71625   arg2 = (float)jarg2;
71626   {
71627     try {
71628       (arg1)->SetScrollFlickDuration(arg2);
71629     } catch (std::out_of_range& e) {
71630       {
71631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71632       };
71633     } catch (std::exception& e) {
71634       {
71635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71636       };
71637     } catch (...) {
71638       {
71639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71640       };
71641     }
71642   }
71643 }
71644
71645
71646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
71647   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71648   Dali::Toolkit::RulerPtr arg2 ;
71649   Dali::Toolkit::RulerPtr *argp2 ;
71650
71651   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71652   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
71653   if (!argp2) {
71654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
71655     return ;
71656   }
71657   arg2 = *argp2;
71658   {
71659     try {
71660       (arg1)->SetRulerX(arg2);
71661     } catch (std::out_of_range& e) {
71662       {
71663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71664       };
71665     } catch (std::exception& e) {
71666       {
71667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71668       };
71669     } catch (...) {
71670       {
71671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71672       };
71673     }
71674   }
71675 }
71676
71677
71678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
71679   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71680   Dali::Toolkit::RulerPtr arg2 ;
71681   Dali::Toolkit::RulerPtr *argp2 ;
71682
71683   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71684   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
71685   if (!argp2) {
71686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
71687     return ;
71688   }
71689   arg2 = *argp2;
71690   {
71691     try {
71692       (arg1)->SetRulerY(arg2);
71693     } catch (std::out_of_range& e) {
71694       {
71695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71696       };
71697     } catch (std::exception& e) {
71698       {
71699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71700       };
71701     } catch (...) {
71702       {
71703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71704       };
71705     }
71706   }
71707 }
71708
71709
71710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
71711   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71712   bool arg2 ;
71713
71714   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71715   arg2 = jarg2 ? true : false;
71716   {
71717     try {
71718       (arg1)->SetScrollSensitive(arg2);
71719     } catch (std::out_of_range& e) {
71720       {
71721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71722       };
71723     } catch (std::exception& e) {
71724       {
71725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71726       };
71727     } catch (...) {
71728       {
71729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71730       };
71731     }
71732   }
71733 }
71734
71735
71736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
71737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71738   float arg2 ;
71739   float arg3 ;
71740
71741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71742   arg2 = (float)jarg2;
71743   arg3 = (float)jarg3;
71744   {
71745     try {
71746       (arg1)->SetMaxOvershoot(arg2,arg3);
71747     } catch (std::out_of_range& e) {
71748       {
71749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71750       };
71751     } catch (std::exception& e) {
71752       {
71753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71754       };
71755     } catch (...) {
71756       {
71757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71758       };
71759     }
71760   }
71761 }
71762
71763
71764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
71765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71766   Dali::AlphaFunction arg2 ;
71767   Dali::AlphaFunction *argp2 ;
71768
71769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71770   argp2 = (Dali::AlphaFunction *)jarg2;
71771   if (!argp2) {
71772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71773     return ;
71774   }
71775   arg2 = *argp2;
71776   {
71777     try {
71778       (arg1)->SetSnapOvershootAlphaFunction(arg2);
71779     } catch (std::out_of_range& e) {
71780       {
71781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71782       };
71783     } catch (std::exception& e) {
71784       {
71785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71786       };
71787     } catch (...) {
71788       {
71789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71790       };
71791     }
71792   }
71793 }
71794
71795
71796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
71797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71798   float arg2 ;
71799
71800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71801   arg2 = (float)jarg2;
71802   {
71803     try {
71804       (arg1)->SetSnapOvershootDuration(arg2);
71805     } catch (std::out_of_range& e) {
71806       {
71807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71808       };
71809     } catch (std::exception& e) {
71810       {
71811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71812       };
71813     } catch (...) {
71814       {
71815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71816       };
71817     }
71818   }
71819 }
71820
71821
71822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
71823   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71824   bool arg2 ;
71825
71826   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71827   arg2 = jarg2 ? true : false;
71828   {
71829     try {
71830       (arg1)->SetActorAutoSnap(arg2);
71831     } catch (std::out_of_range& e) {
71832       {
71833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71834       };
71835     } catch (std::exception& e) {
71836       {
71837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71838       };
71839     } catch (...) {
71840       {
71841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71842       };
71843     }
71844   }
71845 }
71846
71847
71848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
71849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71850   bool arg2 ;
71851
71852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71853   arg2 = jarg2 ? true : false;
71854   {
71855     try {
71856       (arg1)->SetWrapMode(arg2);
71857     } catch (std::out_of_range& e) {
71858       {
71859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71860       };
71861     } catch (std::exception& e) {
71862       {
71863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71864       };
71865     } catch (...) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71868       };
71869     }
71870   }
71871 }
71872
71873
71874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
71875   int jresult ;
71876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71877   int result;
71878
71879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71880   {
71881     try {
71882       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
71883     } catch (std::out_of_range& e) {
71884       {
71885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71886       };
71887     } catch (std::exception& e) {
71888       {
71889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71890       };
71891     } catch (...) {
71892       {
71893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71894       };
71895     }
71896   }
71897   jresult = result;
71898   return jresult;
71899 }
71900
71901
71902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
71903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71904   int arg2 ;
71905
71906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71907   arg2 = (int)jarg2;
71908   {
71909     try {
71910       (arg1)->SetScrollUpdateDistance(arg2);
71911     } catch (std::out_of_range& e) {
71912       {
71913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71914       };
71915     } catch (std::exception& e) {
71916       {
71917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71918       };
71919     } catch (...) {
71920       {
71921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71922       };
71923     }
71924   }
71925 }
71926
71927
71928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
71929   unsigned int jresult ;
71930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71931   bool result;
71932
71933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71934   {
71935     try {
71936       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
71937     } catch (std::out_of_range& e) {
71938       {
71939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71940       };
71941     } catch (std::exception& e) {
71942       {
71943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71944       };
71945     } catch (...) {
71946       {
71947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71948       };
71949     }
71950   }
71951   jresult = result;
71952   return jresult;
71953 }
71954
71955
71956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
71957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71958   bool arg2 ;
71959
71960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71961   arg2 = jarg2 ? true : false;
71962   {
71963     try {
71964       (arg1)->SetAxisAutoLock(arg2);
71965     } catch (std::out_of_range& e) {
71966       {
71967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71968       };
71969     } catch (std::exception& e) {
71970       {
71971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71972       };
71973     } catch (...) {
71974       {
71975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71976       };
71977     }
71978   }
71979 }
71980
71981
71982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
71983   float jresult ;
71984   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71985   float result;
71986
71987   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71988   {
71989     try {
71990       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
71991     } catch (std::out_of_range& e) {
71992       {
71993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71994       };
71995     } catch (std::exception& e) {
71996       {
71997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71998       };
71999     } catch (...) {
72000       {
72001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72002       };
72003     }
72004   }
72005   jresult = result;
72006   return jresult;
72007 }
72008
72009
72010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
72011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72012   float arg2 ;
72013
72014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72015   arg2 = (float)jarg2;
72016   {
72017     try {
72018       (arg1)->SetAxisAutoLockGradient(arg2);
72019     } catch (std::out_of_range& e) {
72020       {
72021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72022       };
72023     } catch (std::exception& e) {
72024       {
72025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72026       };
72027     } catch (...) {
72028       {
72029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72030       };
72031     }
72032   }
72033 }
72034
72035
72036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
72037   float jresult ;
72038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72039   float result;
72040
72041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72042   {
72043     try {
72044       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
72045     } catch (std::out_of_range& e) {
72046       {
72047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72048       };
72049     } catch (std::exception& e) {
72050       {
72051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72052       };
72053     } catch (...) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72056       };
72057     }
72058   }
72059   jresult = result;
72060   return jresult;
72061 }
72062
72063
72064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
72065   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72066   float arg2 ;
72067
72068   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72069   arg2 = (float)jarg2;
72070   {
72071     try {
72072       (arg1)->SetFrictionCoefficient(arg2);
72073     } catch (std::out_of_range& e) {
72074       {
72075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72076       };
72077     } catch (std::exception& e) {
72078       {
72079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72080       };
72081     } catch (...) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72084       };
72085     }
72086   }
72087 }
72088
72089
72090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
72091   float jresult ;
72092   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72093   float result;
72094
72095   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72096   {
72097     try {
72098       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
72099     } catch (std::out_of_range& e) {
72100       {
72101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72102       };
72103     } catch (std::exception& e) {
72104       {
72105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72106       };
72107     } catch (...) {
72108       {
72109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72110       };
72111     }
72112   }
72113   jresult = result;
72114   return jresult;
72115 }
72116
72117
72118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
72119   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72120   float arg2 ;
72121
72122   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72123   arg2 = (float)jarg2;
72124   {
72125     try {
72126       (arg1)->SetFlickSpeedCoefficient(arg2);
72127     } catch (std::out_of_range& e) {
72128       {
72129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72130       };
72131     } catch (std::exception& e) {
72132       {
72133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72134       };
72135     } catch (...) {
72136       {
72137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72138       };
72139     }
72140   }
72141 }
72142
72143
72144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
72145   void * jresult ;
72146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72147   Dali::Vector2 result;
72148
72149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72150   {
72151     try {
72152       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
72153     } catch (std::out_of_range& e) {
72154       {
72155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72156       };
72157     } catch (std::exception& e) {
72158       {
72159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72160       };
72161     } catch (...) {
72162       {
72163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72164       };
72165     }
72166   }
72167   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72168   return jresult;
72169 }
72170
72171
72172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
72173   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72174   Dali::Vector2 *arg2 = 0 ;
72175
72176   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72177   arg2 = (Dali::Vector2 *)jarg2;
72178   if (!arg2) {
72179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72180     return ;
72181   }
72182   {
72183     try {
72184       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
72185     } catch (std::out_of_range& e) {
72186       {
72187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72188       };
72189     } catch (std::exception& e) {
72190       {
72191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72192       };
72193     } catch (...) {
72194       {
72195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72196       };
72197     }
72198   }
72199 }
72200
72201
72202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
72203   float jresult ;
72204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72205   float result;
72206
72207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72208   {
72209     try {
72210       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
72211     } catch (std::out_of_range& e) {
72212       {
72213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72214       };
72215     } catch (std::exception& e) {
72216       {
72217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72218       };
72219     } catch (...) {
72220       {
72221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72222       };
72223     }
72224   }
72225   jresult = result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
72231   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72232   float arg2 ;
72233
72234   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72235   arg2 = (float)jarg2;
72236   {
72237     try {
72238       (arg1)->SetMinimumSpeedForFlick(arg2);
72239     } catch (std::out_of_range& e) {
72240       {
72241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72242       };
72243     } catch (std::exception& e) {
72244       {
72245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72246       };
72247     } catch (...) {
72248       {
72249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72250       };
72251     }
72252   }
72253 }
72254
72255
72256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
72257   float jresult ;
72258   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72259   float result;
72260
72261   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72262   {
72263     try {
72264       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
72265     } catch (std::out_of_range& e) {
72266       {
72267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72268       };
72269     } catch (std::exception& e) {
72270       {
72271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72272       };
72273     } catch (...) {
72274       {
72275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72276       };
72277     }
72278   }
72279   jresult = result;
72280   return jresult;
72281 }
72282
72283
72284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
72285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72286   float arg2 ;
72287
72288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72289   arg2 = (float)jarg2;
72290   {
72291     try {
72292       (arg1)->SetMaxFlickSpeed(arg2);
72293     } catch (std::out_of_range& e) {
72294       {
72295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72296       };
72297     } catch (std::exception& e) {
72298       {
72299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72300       };
72301     } catch (...) {
72302       {
72303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72304       };
72305     }
72306   }
72307 }
72308
72309
72310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
72311   void * jresult ;
72312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72313   Dali::Vector2 result;
72314
72315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72316   {
72317     try {
72318       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
72319     } catch (std::out_of_range& e) {
72320       {
72321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72322       };
72323     } catch (std::exception& e) {
72324       {
72325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72326       };
72327     } catch (...) {
72328       {
72329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72330       };
72331     }
72332   }
72333   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72334   return jresult;
72335 }
72336
72337
72338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
72339   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72340   Dali::Vector2 arg2 ;
72341   Dali::Vector2 *argp2 ;
72342
72343   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72344   argp2 = (Dali::Vector2 *)jarg2;
72345   if (!argp2) {
72346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
72347     return ;
72348   }
72349   arg2 = *argp2;
72350   {
72351     try {
72352       (arg1)->SetWheelScrollDistanceStep(arg2);
72353     } catch (std::out_of_range& e) {
72354       {
72355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72356       };
72357     } catch (std::exception& e) {
72358       {
72359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72360       };
72361     } catch (...) {
72362       {
72363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72364       };
72365     }
72366   }
72367 }
72368
72369
72370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
72371   void * jresult ;
72372   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72373   Dali::Vector2 result;
72374
72375   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72376   {
72377     try {
72378       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
72379     } catch (std::out_of_range& e) {
72380       {
72381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72382       };
72383     } catch (std::exception& e) {
72384       {
72385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72386       };
72387     } catch (...) {
72388       {
72389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72390       };
72391     }
72392   }
72393   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72394   return jresult;
72395 }
72396
72397
72398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
72399   unsigned int jresult ;
72400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72401   unsigned int result;
72402
72403   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72404   {
72405     try {
72406       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
72407     } catch (std::out_of_range& e) {
72408       {
72409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72410       };
72411     } catch (std::exception& e) {
72412       {
72413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72414       };
72415     } catch (...) {
72416       {
72417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72418       };
72419     }
72420   }
72421   jresult = result;
72422   return jresult;
72423 }
72424
72425
72426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
72427   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72428   Dali::Vector2 *arg2 = 0 ;
72429
72430   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72431   arg2 = (Dali::Vector2 *)jarg2;
72432   if (!arg2) {
72433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72434     return ;
72435   }
72436   {
72437     try {
72438       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
72439     } catch (std::out_of_range& e) {
72440       {
72441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72442       };
72443     } catch (std::exception& e) {
72444       {
72445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72446       };
72447     } catch (...) {
72448       {
72449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72450       };
72451     }
72452   }
72453 }
72454
72455
72456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
72457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72458   Dali::Vector2 *arg2 = 0 ;
72459   float arg3 ;
72460
72461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72462   arg2 = (Dali::Vector2 *)jarg2;
72463   if (!arg2) {
72464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72465     return ;
72466   }
72467   arg3 = (float)jarg3;
72468   {
72469     try {
72470       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
72471     } catch (std::out_of_range& e) {
72472       {
72473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72474       };
72475     } catch (std::exception& e) {
72476       {
72477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72478       };
72479     } catch (...) {
72480       {
72481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72482       };
72483     }
72484   }
72485 }
72486
72487
72488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
72489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72490   Dali::Vector2 *arg2 = 0 ;
72491   float arg3 ;
72492   Dali::AlphaFunction arg4 ;
72493   Dali::AlphaFunction *argp4 ;
72494
72495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72496   arg2 = (Dali::Vector2 *)jarg2;
72497   if (!arg2) {
72498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72499     return ;
72500   }
72501   arg3 = (float)jarg3;
72502   argp4 = (Dali::AlphaFunction *)jarg4;
72503   if (!argp4) {
72504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72505     return ;
72506   }
72507   arg4 = *argp4;
72508   {
72509     try {
72510       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
72511     } catch (std::out_of_range& e) {
72512       {
72513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72514       };
72515     } catch (std::exception& e) {
72516       {
72517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72518       };
72519     } catch (...) {
72520       {
72521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72522       };
72523     }
72524   }
72525 }
72526
72527
72528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
72529   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72530   Dali::Vector2 *arg2 = 0 ;
72531   float arg3 ;
72532   Dali::Toolkit::DirectionBias arg4 ;
72533   Dali::Toolkit::DirectionBias arg5 ;
72534
72535   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72536   arg2 = (Dali::Vector2 *)jarg2;
72537   if (!arg2) {
72538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72539     return ;
72540   }
72541   arg3 = (float)jarg3;
72542   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
72543   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
72544   {
72545     try {
72546       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
72547     } catch (std::out_of_range& e) {
72548       {
72549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72550       };
72551     } catch (std::exception& e) {
72552       {
72553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72554       };
72555     } catch (...) {
72556       {
72557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72558       };
72559     }
72560   }
72561 }
72562
72563
72564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
72565   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72566   Dali::Vector2 *arg2 = 0 ;
72567   float arg3 ;
72568   Dali::AlphaFunction arg4 ;
72569   Dali::Toolkit::DirectionBias arg5 ;
72570   Dali::Toolkit::DirectionBias arg6 ;
72571   Dali::AlphaFunction *argp4 ;
72572
72573   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72574   arg2 = (Dali::Vector2 *)jarg2;
72575   if (!arg2) {
72576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72577     return ;
72578   }
72579   arg3 = (float)jarg3;
72580   argp4 = (Dali::AlphaFunction *)jarg4;
72581   if (!argp4) {
72582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72583     return ;
72584   }
72585   arg4 = *argp4;
72586   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
72587   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
72588   {
72589     try {
72590       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
72591     } catch (std::out_of_range& e) {
72592       {
72593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72594       };
72595     } catch (std::exception& e) {
72596       {
72597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72598       };
72599     } catch (...) {
72600       {
72601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72602       };
72603     }
72604   }
72605 }
72606
72607
72608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
72609   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72610   unsigned int arg2 ;
72611
72612   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72613   arg2 = (unsigned int)jarg2;
72614   {
72615     try {
72616       (arg1)->ScrollTo(arg2);
72617     } catch (std::out_of_range& e) {
72618       {
72619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72620       };
72621     } catch (std::exception& e) {
72622       {
72623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72624       };
72625     } catch (...) {
72626       {
72627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72628       };
72629     }
72630   }
72631 }
72632
72633
72634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
72635   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72636   unsigned int arg2 ;
72637   float arg3 ;
72638
72639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72640   arg2 = (unsigned int)jarg2;
72641   arg3 = (float)jarg3;
72642   {
72643     try {
72644       (arg1)->ScrollTo(arg2,arg3);
72645     } catch (std::out_of_range& e) {
72646       {
72647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72648       };
72649     } catch (std::exception& e) {
72650       {
72651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72652       };
72653     } catch (...) {
72654       {
72655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72656       };
72657     }
72658   }
72659 }
72660
72661
72662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
72663   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72664   unsigned int arg2 ;
72665   float arg3 ;
72666   Dali::Toolkit::DirectionBias arg4 ;
72667
72668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72669   arg2 = (unsigned int)jarg2;
72670   arg3 = (float)jarg3;
72671   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
72672   {
72673     try {
72674       (arg1)->ScrollTo(arg2,arg3,arg4);
72675     } catch (std::out_of_range& e) {
72676       {
72677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72678       };
72679     } catch (std::exception& e) {
72680       {
72681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72682       };
72683     } catch (...) {
72684       {
72685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72686       };
72687     }
72688   }
72689 }
72690
72691
72692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
72693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72694   Dali::Actor *arg2 = 0 ;
72695
72696   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72697   arg2 = (Dali::Actor *)jarg2;
72698   if (!arg2) {
72699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72700     return ;
72701   }
72702   {
72703     try {
72704       (arg1)->ScrollTo(*arg2);
72705     } catch (std::out_of_range& e) {
72706       {
72707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72708       };
72709     } catch (std::exception& e) {
72710       {
72711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72712       };
72713     } catch (...) {
72714       {
72715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72716       };
72717     }
72718   }
72719 }
72720
72721
72722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
72723   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72724   Dali::Actor *arg2 = 0 ;
72725   float arg3 ;
72726
72727   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72728   arg2 = (Dali::Actor *)jarg2;
72729   if (!arg2) {
72730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72731     return ;
72732   }
72733   arg3 = (float)jarg3;
72734   {
72735     try {
72736       (arg1)->ScrollTo(*arg2,arg3);
72737     } catch (std::out_of_range& e) {
72738       {
72739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72740       };
72741     } catch (std::exception& e) {
72742       {
72743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72744       };
72745     } catch (...) {
72746       {
72747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72748       };
72749     }
72750   }
72751 }
72752
72753
72754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
72755   unsigned int jresult ;
72756   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72757   bool result;
72758
72759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72760   {
72761     try {
72762       result = (bool)(arg1)->ScrollToSnapPoint();
72763     } catch (std::out_of_range& e) {
72764       {
72765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72766       };
72767     } catch (std::exception& e) {
72768       {
72769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72770       };
72771     } catch (...) {
72772       {
72773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72774       };
72775     }
72776   }
72777   jresult = result;
72778   return jresult;
72779 }
72780
72781
72782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
72783   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72784   Dali::Constraint arg2 ;
72785   Dali::Constraint *argp2 ;
72786
72787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72788   argp2 = (Dali::Constraint *)jarg2;
72789   if (!argp2) {
72790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
72791     return ;
72792   }
72793   arg2 = *argp2;
72794   {
72795     try {
72796       (arg1)->ApplyConstraintToChildren(arg2);
72797     } catch (std::out_of_range& e) {
72798       {
72799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72800       };
72801     } catch (std::exception& e) {
72802       {
72803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72804       };
72805     } catch (...) {
72806       {
72807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72808       };
72809     }
72810   }
72811 }
72812
72813
72814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
72815   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72816
72817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72818   {
72819     try {
72820       (arg1)->RemoveConstraintsFromChildren();
72821     } catch (std::out_of_range& e) {
72822       {
72823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72824       };
72825     } catch (std::exception& e) {
72826       {
72827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72828       };
72829     } catch (...) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72832       };
72833     }
72834   }
72835 }
72836
72837
72838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
72839   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72840   Dali::Toolkit::ScrollViewEffect arg2 ;
72841   Dali::Toolkit::ScrollViewEffect *argp2 ;
72842
72843   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72844   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
72845   if (!argp2) {
72846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
72847     return ;
72848   }
72849   arg2 = *argp2;
72850   {
72851     try {
72852       (arg1)->ApplyEffect(arg2);
72853     } catch (std::out_of_range& e) {
72854       {
72855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72856       };
72857     } catch (std::exception& e) {
72858       {
72859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72860       };
72861     } catch (...) {
72862       {
72863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72864       };
72865     }
72866   }
72867 }
72868
72869
72870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
72871   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72872   Dali::Toolkit::ScrollViewEffect arg2 ;
72873   Dali::Toolkit::ScrollViewEffect *argp2 ;
72874
72875   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72876   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
72877   if (!argp2) {
72878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
72879     return ;
72880   }
72881   arg2 = *argp2;
72882   {
72883     try {
72884       (arg1)->RemoveEffect(arg2);
72885     } catch (std::out_of_range& e) {
72886       {
72887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72888       };
72889     } catch (std::exception& e) {
72890       {
72891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72892       };
72893     } catch (...) {
72894       {
72895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72896       };
72897     }
72898   }
72899 }
72900
72901
72902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
72903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72904
72905   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72906   {
72907     try {
72908       (arg1)->RemoveAllEffects();
72909     } catch (std::out_of_range& e) {
72910       {
72911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72912       };
72913     } catch (std::exception& e) {
72914       {
72915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72916       };
72917     } catch (...) {
72918       {
72919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72920       };
72921     }
72922   }
72923 }
72924
72925
72926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
72927   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72928   Dali::Actor arg2 ;
72929   Dali::Actor *argp2 ;
72930
72931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72932   argp2 = (Dali::Actor *)jarg2;
72933   if (!argp2) {
72934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72935     return ;
72936   }
72937   arg2 = *argp2;
72938   {
72939     try {
72940       (arg1)->BindActor(arg2);
72941     } catch (std::out_of_range& e) {
72942       {
72943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72944       };
72945     } catch (std::exception& e) {
72946       {
72947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72948       };
72949     } catch (...) {
72950       {
72951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72952       };
72953     }
72954   }
72955 }
72956
72957
72958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
72959   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72960   Dali::Actor arg2 ;
72961   Dali::Actor *argp2 ;
72962
72963   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72964   argp2 = (Dali::Actor *)jarg2;
72965   if (!argp2) {
72966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72967     return ;
72968   }
72969   arg2 = *argp2;
72970   {
72971     try {
72972       (arg1)->UnbindActor(arg2);
72973     } catch (std::out_of_range& e) {
72974       {
72975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72976       };
72977     } catch (std::exception& e) {
72978       {
72979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72980       };
72981     } catch (...) {
72982       {
72983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72984       };
72985     }
72986   }
72987 }
72988
72989
72990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
72991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72992   Dali::Radian arg2 ;
72993   Dali::Radian arg3 ;
72994   Dali::Radian *argp2 ;
72995   Dali::Radian *argp3 ;
72996
72997   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72998   argp2 = (Dali::Radian *)jarg2;
72999   if (!argp2) {
73000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73001     return ;
73002   }
73003   arg2 = *argp2;
73004   argp3 = (Dali::Radian *)jarg3;
73005   if (!argp3) {
73006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73007     return ;
73008   }
73009   arg3 = *argp3;
73010   {
73011     try {
73012       (arg1)->SetScrollingDirection(arg2,arg3);
73013     } catch (std::out_of_range& e) {
73014       {
73015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73016       };
73017     } catch (std::exception& e) {
73018       {
73019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73020       };
73021     } catch (...) {
73022       {
73023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73024       };
73025     }
73026   }
73027 }
73028
73029
73030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
73031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73032   Dali::Radian arg2 ;
73033   Dali::Radian *argp2 ;
73034
73035   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73036   argp2 = (Dali::Radian *)jarg2;
73037   if (!argp2) {
73038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73039     return ;
73040   }
73041   arg2 = *argp2;
73042   {
73043     try {
73044       (arg1)->SetScrollingDirection(arg2);
73045     } catch (std::out_of_range& e) {
73046       {
73047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73048       };
73049     } catch (std::exception& e) {
73050       {
73051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73052       };
73053     } catch (...) {
73054       {
73055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73056       };
73057     }
73058   }
73059 }
73060
73061
73062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
73063   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73064   Dali::Radian arg2 ;
73065   Dali::Radian *argp2 ;
73066
73067   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73068   argp2 = (Dali::Radian *)jarg2;
73069   if (!argp2) {
73070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73071     return ;
73072   }
73073   arg2 = *argp2;
73074   {
73075     try {
73076       (arg1)->RemoveScrollingDirection(arg2);
73077     } catch (std::out_of_range& e) {
73078       {
73079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73080       };
73081     } catch (std::exception& e) {
73082       {
73083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73084       };
73085     } catch (...) {
73086       {
73087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73088       };
73089     }
73090   }
73091 }
73092
73093
73094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
73095   void * jresult ;
73096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73097   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
73098
73099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73100   {
73101     try {
73102       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
73103     } catch (std::out_of_range& e) {
73104       {
73105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73106       };
73107     } catch (std::exception& e) {
73108       {
73109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73110       };
73111     } catch (...) {
73112       {
73113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73114       };
73115     }
73116   }
73117   jresult = (void *)result;
73118   return jresult;
73119 }
73120
73121
73122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
73123   int jresult ;
73124   int result;
73125
73126   result = (int)Dali::Toolkit::TableView::Property::ROWS;
73127   jresult = (int)result;
73128   return jresult;
73129 }
73130
73131
73132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
73133   int jresult ;
73134   int result;
73135
73136   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
73137   jresult = (int)result;
73138   return jresult;
73139 }
73140
73141
73142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
73143   int jresult ;
73144   int result;
73145
73146   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
73147   jresult = (int)result;
73148   return jresult;
73149 }
73150
73151
73152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
73153   int jresult ;
73154   int result;
73155
73156   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
73157   jresult = (int)result;
73158   return jresult;
73159 }
73160
73161
73162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
73163   int jresult ;
73164   int result;
73165
73166   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
73167   jresult = (int)result;
73168   return jresult;
73169 }
73170
73171
73172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
73173   void * jresult ;
73174   Dali::Toolkit::TableView::Property *result = 0 ;
73175
73176   {
73177     try {
73178       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
73179     } catch (std::out_of_range& e) {
73180       {
73181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73182       };
73183     } catch (std::exception& e) {
73184       {
73185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73186       };
73187     } catch (...) {
73188       {
73189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73190       };
73191     }
73192   }
73193   jresult = (void *)result;
73194   return jresult;
73195 }
73196
73197
73198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
73199   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
73200
73201   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
73202   {
73203     try {
73204       delete arg1;
73205     } catch (std::out_of_range& e) {
73206       {
73207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73208       };
73209     } catch (std::exception& e) {
73210       {
73211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73212       };
73213     } catch (...) {
73214       {
73215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73216       };
73217     }
73218   }
73219 }
73220
73221
73222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
73223   int jresult ;
73224   int result;
73225
73226   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
73227   jresult = (int)result;
73228   return jresult;
73229 }
73230
73231
73232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
73233   int jresult ;
73234   int result;
73235
73236   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
73237   jresult = (int)result;
73238   return jresult;
73239 }
73240
73241
73242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
73243   int jresult ;
73244   int result;
73245
73246   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
73247   jresult = (int)result;
73248   return jresult;
73249 }
73250
73251
73252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
73253   int jresult ;
73254   int result;
73255
73256   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
73257   jresult = (int)result;
73258   return jresult;
73259 }
73260
73261
73262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
73263   int jresult ;
73264   int result;
73265
73266   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
73267   jresult = (int)result;
73268   return jresult;
73269 }
73270
73271
73272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
73273   void * jresult ;
73274   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
73275
73276   {
73277     try {
73278       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
73279     } catch (std::out_of_range& e) {
73280       {
73281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73282       };
73283     } catch (std::exception& e) {
73284       {
73285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73286       };
73287     } catch (...) {
73288       {
73289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73290       };
73291     }
73292   }
73293   jresult = (void *)result;
73294   return jresult;
73295 }
73296
73297
73298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
73299   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
73300
73301   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
73302   {
73303     try {
73304       delete arg1;
73305     } catch (std::out_of_range& e) {
73306       {
73307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73308       };
73309     } catch (std::exception& e) {
73310       {
73311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73312       };
73313     } catch (...) {
73314       {
73315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73316       };
73317     }
73318   }
73319 }
73320
73321
73322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
73323   void * jresult ;
73324   unsigned int arg1 ;
73325   unsigned int arg2 ;
73326   unsigned int arg3 ;
73327   unsigned int arg4 ;
73328   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73329
73330   arg1 = (unsigned int)jarg1;
73331   arg2 = (unsigned int)jarg2;
73332   arg3 = (unsigned int)jarg3;
73333   arg4 = (unsigned int)jarg4;
73334   {
73335     try {
73336       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
73337     } catch (std::out_of_range& e) {
73338       {
73339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73340       };
73341     } catch (std::exception& e) {
73342       {
73343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73344       };
73345     } catch (...) {
73346       {
73347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73348       };
73349     }
73350   }
73351   jresult = (void *)result;
73352   return jresult;
73353 }
73354
73355
73356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
73357   void * jresult ;
73358   unsigned int arg1 ;
73359   unsigned int arg2 ;
73360   unsigned int arg3 ;
73361   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73362
73363   arg1 = (unsigned int)jarg1;
73364   arg2 = (unsigned int)jarg2;
73365   arg3 = (unsigned int)jarg3;
73366   {
73367     try {
73368       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
73369     } catch (std::out_of_range& e) {
73370       {
73371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73372       };
73373     } catch (std::exception& e) {
73374       {
73375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73376       };
73377     } catch (...) {
73378       {
73379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73380       };
73381     }
73382   }
73383   jresult = (void *)result;
73384   return jresult;
73385 }
73386
73387
73388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
73389   void * jresult ;
73390   unsigned int arg1 ;
73391   unsigned int arg2 ;
73392   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73393
73394   arg1 = (unsigned int)jarg1;
73395   arg2 = (unsigned int)jarg2;
73396   {
73397     try {
73398       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
73399     } catch (std::out_of_range& e) {
73400       {
73401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73402       };
73403     } catch (std::exception& e) {
73404       {
73405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73406       };
73407     } catch (...) {
73408       {
73409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73410       };
73411     }
73412   }
73413   jresult = (void *)result;
73414   return jresult;
73415 }
73416
73417
73418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
73419   void * jresult ;
73420   unsigned int arg1 ;
73421   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73422
73423   arg1 = (unsigned int)jarg1;
73424   {
73425     try {
73426       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
73427     } catch (std::out_of_range& e) {
73428       {
73429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73430       };
73431     } catch (std::exception& e) {
73432       {
73433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73434       };
73435     } catch (...) {
73436       {
73437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73438       };
73439     }
73440   }
73441   jresult = (void *)result;
73442   return jresult;
73443 }
73444
73445
73446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
73447   void * jresult ;
73448   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73449
73450   {
73451     try {
73452       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
73453     } catch (std::out_of_range& e) {
73454       {
73455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73456       };
73457     } catch (std::exception& e) {
73458       {
73459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73460       };
73461     } catch (...) {
73462       {
73463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73464       };
73465     }
73466   }
73467   jresult = (void *)result;
73468   return jresult;
73469 }
73470
73471
73472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
73473   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73474   unsigned int arg2 ;
73475
73476   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73477   arg2 = (unsigned int)jarg2;
73478   if (arg1) (arg1)->rowIndex = arg2;
73479 }
73480
73481
73482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
73483   unsigned int jresult ;
73484   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73485   unsigned int result;
73486
73487   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73488   result = (unsigned int) ((arg1)->rowIndex);
73489   jresult = result;
73490   return jresult;
73491 }
73492
73493
73494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
73495   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73496   unsigned int arg2 ;
73497
73498   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73499   arg2 = (unsigned int)jarg2;
73500   if (arg1) (arg1)->columnIndex = arg2;
73501 }
73502
73503
73504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
73505   unsigned int jresult ;
73506   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73507   unsigned int result;
73508
73509   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73510   result = (unsigned int) ((arg1)->columnIndex);
73511   jresult = result;
73512   return jresult;
73513 }
73514
73515
73516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
73517   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73518   unsigned int arg2 ;
73519
73520   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73521   arg2 = (unsigned int)jarg2;
73522   if (arg1) (arg1)->rowSpan = arg2;
73523 }
73524
73525
73526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
73527   unsigned int jresult ;
73528   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73529   unsigned int result;
73530
73531   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73532   result = (unsigned int) ((arg1)->rowSpan);
73533   jresult = result;
73534   return jresult;
73535 }
73536
73537
73538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
73539   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73540   unsigned int arg2 ;
73541
73542   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73543   arg2 = (unsigned int)jarg2;
73544   if (arg1) (arg1)->columnSpan = arg2;
73545 }
73546
73547
73548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
73549   unsigned int jresult ;
73550   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73551   unsigned int result;
73552
73553   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73554   result = (unsigned int) ((arg1)->columnSpan);
73555   jresult = result;
73556   return jresult;
73557 }
73558
73559
73560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
73561   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73562
73563   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73564   {
73565     try {
73566       delete arg1;
73567     } catch (std::out_of_range& e) {
73568       {
73569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73570       };
73571     } catch (std::exception& e) {
73572       {
73573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73574       };
73575     } catch (...) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73578       };
73579     }
73580   }
73581 }
73582
73583
73584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
73585   void * jresult ;
73586   Dali::Toolkit::TableView *result = 0 ;
73587
73588   {
73589     try {
73590       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
73591     } catch (std::out_of_range& e) {
73592       {
73593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73594       };
73595     } catch (std::exception& e) {
73596       {
73597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73598       };
73599     } catch (...) {
73600       {
73601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73602       };
73603     }
73604   }
73605   jresult = (void *)result;
73606   return jresult;
73607 }
73608
73609
73610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
73611   void * jresult ;
73612   Dali::Toolkit::TableView *arg1 = 0 ;
73613   Dali::Toolkit::TableView *result = 0 ;
73614
73615   arg1 = (Dali::Toolkit::TableView *)jarg1;
73616   if (!arg1) {
73617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
73618     return 0;
73619   }
73620   {
73621     try {
73622       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
73623     } catch (std::out_of_range& e) {
73624       {
73625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73626       };
73627     } catch (std::exception& e) {
73628       {
73629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73630       };
73631     } catch (...) {
73632       {
73633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73634       };
73635     }
73636   }
73637   jresult = (void *)result;
73638   return jresult;
73639 }
73640
73641
73642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
73643   void * jresult ;
73644   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73645   Dali::Toolkit::TableView *arg2 = 0 ;
73646   Dali::Toolkit::TableView *result = 0 ;
73647
73648   arg1 = (Dali::Toolkit::TableView *)jarg1;
73649   arg2 = (Dali::Toolkit::TableView *)jarg2;
73650   if (!arg2) {
73651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
73652     return 0;
73653   }
73654   {
73655     try {
73656       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
73657     } catch (std::out_of_range& e) {
73658       {
73659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73660       };
73661     } catch (std::exception& e) {
73662       {
73663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73664       };
73665     } catch (...) {
73666       {
73667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73668       };
73669     }
73670   }
73671   jresult = (void *)result;
73672   return jresult;
73673 }
73674
73675
73676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
73677   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73678
73679   arg1 = (Dali::Toolkit::TableView *)jarg1;
73680   {
73681     try {
73682       delete arg1;
73683     } catch (std::out_of_range& e) {
73684       {
73685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73686       };
73687     } catch (std::exception& e) {
73688       {
73689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73690       };
73691     } catch (...) {
73692       {
73693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73694       };
73695     }
73696   }
73697 }
73698
73699
73700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
73701   void * jresult ;
73702   unsigned int arg1 ;
73703   unsigned int arg2 ;
73704   Dali::Toolkit::TableView result;
73705
73706   arg1 = (unsigned int)jarg1;
73707   arg2 = (unsigned int)jarg2;
73708   {
73709     try {
73710       result = Dali::Toolkit::TableView::New(arg1,arg2);
73711     } catch (std::out_of_range& e) {
73712       {
73713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73714       };
73715     } catch (std::exception& e) {
73716       {
73717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73718       };
73719     } catch (...) {
73720       {
73721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73722       };
73723     }
73724   }
73725   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
73726   return jresult;
73727 }
73728
73729
73730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
73731   void * jresult ;
73732   Dali::BaseHandle arg1 ;
73733   Dali::BaseHandle *argp1 ;
73734   Dali::Toolkit::TableView result;
73735
73736   argp1 = (Dali::BaseHandle *)jarg1;
73737   if (!argp1) {
73738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73739     return 0;
73740   }
73741   arg1 = *argp1;
73742   {
73743     try {
73744       result = Dali::Toolkit::TableView::DownCast(arg1);
73745     } catch (std::out_of_range& e) {
73746       {
73747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73748       };
73749     } catch (std::exception& e) {
73750       {
73751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73752       };
73753     } catch (...) {
73754       {
73755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73756       };
73757     }
73758   }
73759   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
73760   return jresult;
73761 }
73762
73763
73764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
73765   unsigned int jresult ;
73766   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73767   Dali::Actor arg2 ;
73768   Dali::Toolkit::TableView::CellPosition arg3 ;
73769   Dali::Actor *argp2 ;
73770   Dali::Toolkit::TableView::CellPosition *argp3 ;
73771   bool result;
73772
73773   arg1 = (Dali::Toolkit::TableView *)jarg1;
73774   argp2 = (Dali::Actor *)jarg2;
73775   if (!argp2) {
73776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73777     return 0;
73778   }
73779   arg2 = *argp2;
73780   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
73781   if (!argp3) {
73782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73783     return 0;
73784   }
73785   arg3 = *argp3;
73786   {
73787     try {
73788       result = (bool)(arg1)->AddChild(arg2,arg3);
73789     } catch (std::out_of_range& e) {
73790       {
73791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73792       };
73793     } catch (std::exception& e) {
73794       {
73795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73796       };
73797     } catch (...) {
73798       {
73799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73800       };
73801     }
73802   }
73803   jresult = result;
73804   return jresult;
73805 }
73806
73807
73808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
73809   void * jresult ;
73810   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73811   Dali::Toolkit::TableView::CellPosition arg2 ;
73812   Dali::Toolkit::TableView::CellPosition *argp2 ;
73813   Dali::Actor result;
73814
73815   arg1 = (Dali::Toolkit::TableView *)jarg1;
73816   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
73817   if (!argp2) {
73818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73819     return 0;
73820   }
73821   arg2 = *argp2;
73822   {
73823     try {
73824       result = (arg1)->GetChildAt(arg2);
73825     } catch (std::out_of_range& e) {
73826       {
73827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73828       };
73829     } catch (std::exception& e) {
73830       {
73831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73832       };
73833     } catch (...) {
73834       {
73835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73836       };
73837     }
73838   }
73839   jresult = new Dali::Actor((const Dali::Actor &)result);
73840   return jresult;
73841 }
73842
73843
73844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
73845   void * jresult ;
73846   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73847   Dali::Toolkit::TableView::CellPosition arg2 ;
73848   Dali::Toolkit::TableView::CellPosition *argp2 ;
73849   Dali::Actor result;
73850
73851   arg1 = (Dali::Toolkit::TableView *)jarg1;
73852   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
73853   if (!argp2) {
73854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73855     return 0;
73856   }
73857   arg2 = *argp2;
73858   {
73859     try {
73860       result = (arg1)->RemoveChildAt(arg2);
73861     } catch (std::out_of_range& e) {
73862       {
73863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73864       };
73865     } catch (std::exception& e) {
73866       {
73867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73868       };
73869     } catch (...) {
73870       {
73871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73872       };
73873     }
73874   }
73875   jresult = new Dali::Actor((const Dali::Actor &)result);
73876   return jresult;
73877 }
73878
73879
73880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
73881   unsigned int jresult ;
73882   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73883   Dali::Actor arg2 ;
73884   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
73885   Dali::Actor *argp2 ;
73886   bool result;
73887
73888   arg1 = (Dali::Toolkit::TableView *)jarg1;
73889   argp2 = (Dali::Actor *)jarg2;
73890   if (!argp2) {
73891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73892     return 0;
73893   }
73894   arg2 = *argp2;
73895   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
73896   if (!arg3) {
73897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
73898     return 0;
73899   }
73900   {
73901     try {
73902       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
73903     } catch (std::out_of_range& e) {
73904       {
73905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73906       };
73907     } catch (std::exception& e) {
73908       {
73909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73910       };
73911     } catch (...) {
73912       {
73913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73914       };
73915     }
73916   }
73917   jresult = result;
73918   return jresult;
73919 }
73920
73921
73922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
73923   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73924   unsigned int arg2 ;
73925
73926   arg1 = (Dali::Toolkit::TableView *)jarg1;
73927   arg2 = (unsigned int)jarg2;
73928   {
73929     try {
73930       (arg1)->InsertRow(arg2);
73931     } catch (std::out_of_range& e) {
73932       {
73933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73934       };
73935     } catch (std::exception& e) {
73936       {
73937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73938       };
73939     } catch (...) {
73940       {
73941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73942       };
73943     }
73944   }
73945 }
73946
73947
73948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
73949   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73950   unsigned int arg2 ;
73951
73952   arg1 = (Dali::Toolkit::TableView *)jarg1;
73953   arg2 = (unsigned int)jarg2;
73954   {
73955     try {
73956       (arg1)->DeleteRow(arg2);
73957     } catch (std::out_of_range& e) {
73958       {
73959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73960       };
73961     } catch (std::exception& e) {
73962       {
73963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73964       };
73965     } catch (...) {
73966       {
73967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73968       };
73969     }
73970   }
73971 }
73972
73973
73974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
73975   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73976   unsigned int arg2 ;
73977   std::vector< Dali::Actor > *arg3 = 0 ;
73978
73979   arg1 = (Dali::Toolkit::TableView *)jarg1;
73980   arg2 = (unsigned int)jarg2;
73981   arg3 = (std::vector< Dali::Actor > *)jarg3;
73982   if (!arg3) {
73983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
73984     return ;
73985   }
73986   {
73987     try {
73988       (arg1)->DeleteRow(arg2,*arg3);
73989     } catch (std::out_of_range& e) {
73990       {
73991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73992       };
73993     } catch (std::exception& e) {
73994       {
73995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73996       };
73997     } catch (...) {
73998       {
73999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74000       };
74001     }
74002   }
74003 }
74004
74005
74006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
74007   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74008   unsigned int arg2 ;
74009
74010   arg1 = (Dali::Toolkit::TableView *)jarg1;
74011   arg2 = (unsigned int)jarg2;
74012   {
74013     try {
74014       (arg1)->InsertColumn(arg2);
74015     } catch (std::out_of_range& e) {
74016       {
74017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74018       };
74019     } catch (std::exception& e) {
74020       {
74021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74022       };
74023     } catch (...) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74026       };
74027     }
74028   }
74029 }
74030
74031
74032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
74033   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74034   unsigned int arg2 ;
74035
74036   arg1 = (Dali::Toolkit::TableView *)jarg1;
74037   arg2 = (unsigned int)jarg2;
74038   {
74039     try {
74040       (arg1)->DeleteColumn(arg2);
74041     } catch (std::out_of_range& e) {
74042       {
74043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74044       };
74045     } catch (std::exception& e) {
74046       {
74047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74048       };
74049     } catch (...) {
74050       {
74051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74052       };
74053     }
74054   }
74055 }
74056
74057
74058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
74059   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74060   unsigned int arg2 ;
74061   std::vector< Dali::Actor > *arg3 = 0 ;
74062
74063   arg1 = (Dali::Toolkit::TableView *)jarg1;
74064   arg2 = (unsigned int)jarg2;
74065   arg3 = (std::vector< Dali::Actor > *)jarg3;
74066   if (!arg3) {
74067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74068     return ;
74069   }
74070   {
74071     try {
74072       (arg1)->DeleteColumn(arg2,*arg3);
74073     } catch (std::out_of_range& e) {
74074       {
74075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74076       };
74077     } catch (std::exception& e) {
74078       {
74079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74080       };
74081     } catch (...) {
74082       {
74083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74084       };
74085     }
74086   }
74087 }
74088
74089
74090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
74091   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74092   unsigned int arg2 ;
74093   unsigned int arg3 ;
74094
74095   arg1 = (Dali::Toolkit::TableView *)jarg1;
74096   arg2 = (unsigned int)jarg2;
74097   arg3 = (unsigned int)jarg3;
74098   {
74099     try {
74100       (arg1)->Resize(arg2,arg3);
74101     } catch (std::out_of_range& e) {
74102       {
74103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74104       };
74105     } catch (std::exception& e) {
74106       {
74107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74108       };
74109     } catch (...) {
74110       {
74111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74112       };
74113     }
74114   }
74115 }
74116
74117
74118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
74119   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74120   unsigned int arg2 ;
74121   unsigned int arg3 ;
74122   std::vector< Dali::Actor > *arg4 = 0 ;
74123
74124   arg1 = (Dali::Toolkit::TableView *)jarg1;
74125   arg2 = (unsigned int)jarg2;
74126   arg3 = (unsigned int)jarg3;
74127   arg4 = (std::vector< Dali::Actor > *)jarg4;
74128   if (!arg4) {
74129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74130     return ;
74131   }
74132   {
74133     try {
74134       (arg1)->Resize(arg2,arg3,*arg4);
74135     } catch (std::out_of_range& e) {
74136       {
74137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74138       };
74139     } catch (std::exception& e) {
74140       {
74141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74142       };
74143     } catch (...) {
74144       {
74145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74146       };
74147     }
74148   }
74149 }
74150
74151
74152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
74153   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74154   Dali::Size arg2 ;
74155   Dali::Size *argp2 ;
74156
74157   arg1 = (Dali::Toolkit::TableView *)jarg1;
74158   argp2 = (Dali::Size *)jarg2;
74159   if (!argp2) {
74160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
74161     return ;
74162   }
74163   arg2 = *argp2;
74164   {
74165     try {
74166       (arg1)->SetCellPadding(arg2);
74167     } catch (std::out_of_range& e) {
74168       {
74169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74170       };
74171     } catch (std::exception& e) {
74172       {
74173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74174       };
74175     } catch (...) {
74176       {
74177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74178       };
74179     }
74180   }
74181 }
74182
74183
74184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
74185   void * jresult ;
74186   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74187   Dali::Size result;
74188
74189   arg1 = (Dali::Toolkit::TableView *)jarg1;
74190   {
74191     try {
74192       result = (arg1)->GetCellPadding();
74193     } catch (std::out_of_range& e) {
74194       {
74195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74196       };
74197     } catch (std::exception& e) {
74198       {
74199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74200       };
74201     } catch (...) {
74202       {
74203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74204       };
74205     }
74206   }
74207   jresult = new Dali::Size((const Dali::Size &)result);
74208   return jresult;
74209 }
74210
74211
74212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
74213   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74214   unsigned int arg2 ;
74215
74216   arg1 = (Dali::Toolkit::TableView *)jarg1;
74217   arg2 = (unsigned int)jarg2;
74218   {
74219     try {
74220       (arg1)->SetFitHeight(arg2);
74221     } catch (std::out_of_range& e) {
74222       {
74223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74224       };
74225     } catch (std::exception& e) {
74226       {
74227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74228       };
74229     } catch (...) {
74230       {
74231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74232       };
74233     }
74234   }
74235 }
74236
74237
74238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
74239   unsigned int jresult ;
74240   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74241   unsigned int arg2 ;
74242   bool result;
74243
74244   arg1 = (Dali::Toolkit::TableView *)jarg1;
74245   arg2 = (unsigned int)jarg2;
74246   {
74247     try {
74248       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
74249     } catch (std::out_of_range& e) {
74250       {
74251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74252       };
74253     } catch (std::exception& e) {
74254       {
74255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74256       };
74257     } catch (...) {
74258       {
74259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74260       };
74261     }
74262   }
74263   jresult = result;
74264   return jresult;
74265 }
74266
74267
74268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
74269   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74270   unsigned int arg2 ;
74271
74272   arg1 = (Dali::Toolkit::TableView *)jarg1;
74273   arg2 = (unsigned int)jarg2;
74274   {
74275     try {
74276       (arg1)->SetFitWidth(arg2);
74277     } catch (std::out_of_range& e) {
74278       {
74279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74280       };
74281     } catch (std::exception& e) {
74282       {
74283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74284       };
74285     } catch (...) {
74286       {
74287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74288       };
74289     }
74290   }
74291 }
74292
74293
74294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
74295   unsigned int jresult ;
74296   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74297   unsigned int arg2 ;
74298   bool result;
74299
74300   arg1 = (Dali::Toolkit::TableView *)jarg1;
74301   arg2 = (unsigned int)jarg2;
74302   {
74303     try {
74304       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
74305     } catch (std::out_of_range& e) {
74306       {
74307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74308       };
74309     } catch (std::exception& e) {
74310       {
74311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74312       };
74313     } catch (...) {
74314       {
74315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74316       };
74317     }
74318   }
74319   jresult = result;
74320   return jresult;
74321 }
74322
74323
74324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
74325   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74326   unsigned int arg2 ;
74327   float arg3 ;
74328
74329   arg1 = (Dali::Toolkit::TableView *)jarg1;
74330   arg2 = (unsigned int)jarg2;
74331   arg3 = (float)jarg3;
74332   {
74333     try {
74334       (arg1)->SetFixedHeight(arg2,arg3);
74335     } catch (std::out_of_range& e) {
74336       {
74337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74338       };
74339     } catch (std::exception& e) {
74340       {
74341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74342       };
74343     } catch (...) {
74344       {
74345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74346       };
74347     }
74348   }
74349 }
74350
74351
74352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
74353   float jresult ;
74354   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74355   unsigned int arg2 ;
74356   float result;
74357
74358   arg1 = (Dali::Toolkit::TableView *)jarg1;
74359   arg2 = (unsigned int)jarg2;
74360   {
74361     try {
74362       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
74363     } catch (std::out_of_range& e) {
74364       {
74365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74366       };
74367     } catch (std::exception& e) {
74368       {
74369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74370       };
74371     } catch (...) {
74372       {
74373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74374       };
74375     }
74376   }
74377   jresult = result;
74378   return jresult;
74379 }
74380
74381
74382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
74383   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74384   unsigned int arg2 ;
74385   float arg3 ;
74386
74387   arg1 = (Dali::Toolkit::TableView *)jarg1;
74388   arg2 = (unsigned int)jarg2;
74389   arg3 = (float)jarg3;
74390   {
74391     try {
74392       (arg1)->SetRelativeHeight(arg2,arg3);
74393     } catch (std::out_of_range& e) {
74394       {
74395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74396       };
74397     } catch (std::exception& e) {
74398       {
74399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74400       };
74401     } catch (...) {
74402       {
74403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74404       };
74405     }
74406   }
74407 }
74408
74409
74410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
74411   float jresult ;
74412   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74413   unsigned int arg2 ;
74414   float result;
74415
74416   arg1 = (Dali::Toolkit::TableView *)jarg1;
74417   arg2 = (unsigned int)jarg2;
74418   {
74419     try {
74420       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
74421     } catch (std::out_of_range& e) {
74422       {
74423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74424       };
74425     } catch (std::exception& e) {
74426       {
74427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74428       };
74429     } catch (...) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74432       };
74433     }
74434   }
74435   jresult = result;
74436   return jresult;
74437 }
74438
74439
74440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
74441   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74442   unsigned int arg2 ;
74443   float arg3 ;
74444
74445   arg1 = (Dali::Toolkit::TableView *)jarg1;
74446   arg2 = (unsigned int)jarg2;
74447   arg3 = (float)jarg3;
74448   {
74449     try {
74450       (arg1)->SetFixedWidth(arg2,arg3);
74451     } catch (std::out_of_range& e) {
74452       {
74453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74454       };
74455     } catch (std::exception& e) {
74456       {
74457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74458       };
74459     } catch (...) {
74460       {
74461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74462       };
74463     }
74464   }
74465 }
74466
74467
74468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
74469   float jresult ;
74470   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74471   unsigned int arg2 ;
74472   float result;
74473
74474   arg1 = (Dali::Toolkit::TableView *)jarg1;
74475   arg2 = (unsigned int)jarg2;
74476   {
74477     try {
74478       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
74479     } catch (std::out_of_range& e) {
74480       {
74481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74482       };
74483     } catch (std::exception& e) {
74484       {
74485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74486       };
74487     } catch (...) {
74488       {
74489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74490       };
74491     }
74492   }
74493   jresult = result;
74494   return jresult;
74495 }
74496
74497
74498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
74499   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74500   unsigned int arg2 ;
74501   float arg3 ;
74502
74503   arg1 = (Dali::Toolkit::TableView *)jarg1;
74504   arg2 = (unsigned int)jarg2;
74505   arg3 = (float)jarg3;
74506   {
74507     try {
74508       (arg1)->SetRelativeWidth(arg2,arg3);
74509     } catch (std::out_of_range& e) {
74510       {
74511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74512       };
74513     } catch (std::exception& e) {
74514       {
74515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74516       };
74517     } catch (...) {
74518       {
74519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74520       };
74521     }
74522   }
74523 }
74524
74525
74526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
74527   float jresult ;
74528   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74529   unsigned int arg2 ;
74530   float result;
74531
74532   arg1 = (Dali::Toolkit::TableView *)jarg1;
74533   arg2 = (unsigned int)jarg2;
74534   {
74535     try {
74536       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
74537     } catch (std::out_of_range& e) {
74538       {
74539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74540       };
74541     } catch (std::exception& e) {
74542       {
74543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74544       };
74545     } catch (...) {
74546       {
74547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74548       };
74549     }
74550   }
74551   jresult = result;
74552   return jresult;
74553 }
74554
74555
74556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
74557   unsigned int jresult ;
74558   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74559   unsigned int result;
74560
74561   arg1 = (Dali::Toolkit::TableView *)jarg1;
74562   {
74563     try {
74564       result = (unsigned int)(arg1)->GetRows();
74565     } catch (std::out_of_range& e) {
74566       {
74567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74568       };
74569     } catch (std::exception& e) {
74570       {
74571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74572       };
74573     } catch (...) {
74574       {
74575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74576       };
74577     }
74578   }
74579   jresult = result;
74580   return jresult;
74581 }
74582
74583
74584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
74585   unsigned int jresult ;
74586   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74587   unsigned int result;
74588
74589   arg1 = (Dali::Toolkit::TableView *)jarg1;
74590   {
74591     try {
74592       result = (unsigned int)(arg1)->GetColumns();
74593     } catch (std::out_of_range& e) {
74594       {
74595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74596       };
74597     } catch (std::exception& e) {
74598       {
74599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74600       };
74601     } catch (...) {
74602       {
74603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74604       };
74605     }
74606   }
74607   jresult = result;
74608   return jresult;
74609 }
74610
74611
74612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
74613   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74614   Dali::Toolkit::TableView::CellPosition arg2 ;
74615   Dali::HorizontalAlignment::Type arg3 ;
74616   Dali::VerticalAlignment::Type arg4 ;
74617   Dali::Toolkit::TableView::CellPosition *argp2 ;
74618
74619   arg1 = (Dali::Toolkit::TableView *)jarg1;
74620   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
74621   if (!argp2) {
74622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
74623     return ;
74624   }
74625   arg2 = *argp2;
74626   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
74627   arg4 = (Dali::VerticalAlignment::Type)jarg4;
74628   {
74629     try {
74630       (arg1)->SetCellAlignment(arg2,arg3,arg4);
74631     } catch (std::out_of_range& e) {
74632       {
74633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74634       };
74635     } catch (std::exception& e) {
74636       {
74637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74638       };
74639     } catch (...) {
74640       {
74641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74642       };
74643     }
74644   }
74645 }
74646
74647
74648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
74649   unsigned int jresult ;
74650   unsigned int result;
74651
74652   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
74653   jresult = result;
74654   return jresult;
74655 }
74656
74657
74658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
74659   int jresult ;
74660   int result;
74661
74662   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
74663   jresult = (int)result;
74664   return jresult;
74665 }
74666
74667
74668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
74669   int jresult ;
74670   int result;
74671
74672   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
74673   jresult = (int)result;
74674   return jresult;
74675 }
74676
74677
74678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
74679   int jresult ;
74680   int result;
74681
74682   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
74683   jresult = (int)result;
74684   return jresult;
74685 }
74686
74687
74688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
74689   int jresult ;
74690   int result;
74691
74692   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
74693   jresult = (int)result;
74694   return jresult;
74695 }
74696
74697
74698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
74699   int jresult ;
74700   int result;
74701
74702   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
74703   jresult = (int)result;
74704   return jresult;
74705 }
74706
74707
74708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
74709   int jresult ;
74710   int result;
74711
74712   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
74713   jresult = (int)result;
74714   return jresult;
74715 }
74716
74717
74718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
74719   int jresult ;
74720   int result;
74721
74722   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
74723   jresult = (int)result;
74724   return jresult;
74725 }
74726
74727
74728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
74729   int jresult ;
74730   int result;
74731
74732   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
74733   jresult = (int)result;
74734   return jresult;
74735 }
74736
74737
74738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
74739   int jresult ;
74740   int result;
74741
74742   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
74743   jresult = (int)result;
74744   return jresult;
74745 }
74746
74747
74748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
74749   int jresult ;
74750   int result;
74751
74752   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
74753   jresult = (int)result;
74754   return jresult;
74755 }
74756
74757
74758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
74759   int jresult ;
74760   int result;
74761
74762   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
74763   jresult = (int)result;
74764   return jresult;
74765 }
74766
74767
74768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
74769   int jresult ;
74770   int result;
74771
74772   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
74773   jresult = (int)result;
74774   return jresult;
74775 }
74776
74777
74778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
74779   int jresult ;
74780   int result;
74781
74782   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
74783   jresult = (int)result;
74784   return jresult;
74785 }
74786
74787
74788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
74789   int jresult ;
74790   int result;
74791
74792   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
74793   jresult = (int)result;
74794   return jresult;
74795 }
74796
74797
74798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
74799   int jresult ;
74800   int result;
74801
74802   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
74803   jresult = (int)result;
74804   return jresult;
74805 }
74806
74807
74808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
74809   int jresult ;
74810   int result;
74811
74812   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
74813   jresult = (int)result;
74814   return jresult;
74815 }
74816
74817
74818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
74819   int jresult ;
74820   int result;
74821
74822   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
74823   jresult = (int)result;
74824   return jresult;
74825 }
74826
74827
74828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
74829   int jresult ;
74830   int result;
74831
74832   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
74833   jresult = (int)result;
74834   return jresult;
74835 }
74836
74837
74838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
74839   int jresult ;
74840   int result;
74841
74842   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
74843   jresult = (int)result;
74844   return jresult;
74845 }
74846
74847
74848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
74849   int jresult ;
74850   int result;
74851
74852   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
74853   jresult = (int)result;
74854   return jresult;
74855 }
74856
74857
74858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
74859   int jresult ;
74860   int result;
74861
74862   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
74863   jresult = (int)result;
74864   return jresult;
74865 }
74866
74867
74868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
74869   int jresult ;
74870   int result;
74871
74872   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
74873   jresult = (int)result;
74874   return jresult;
74875 }
74876
74877
74878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
74879   int jresult ;
74880   int result;
74881
74882   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
74883   jresult = (int)result;
74884   return jresult;
74885 }
74886
74887
74888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
74889   int jresult ;
74890   int result;
74891
74892   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
74893   jresult = (int)result;
74894   return jresult;
74895 }
74896
74897
74898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
74899   void * jresult ;
74900   Dali::Toolkit::TextLabel::Property *result = 0 ;
74901
74902   {
74903     try {
74904       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
74905     } catch (std::out_of_range& e) {
74906       {
74907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74908       };
74909     } catch (std::exception& e) {
74910       {
74911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74912       };
74913     } catch (...) {
74914       {
74915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74916       };
74917     }
74918   }
74919   jresult = (void *)result;
74920   return jresult;
74921 }
74922
74923
74924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
74925   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
74926
74927   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
74928   {
74929     try {
74930       delete arg1;
74931     } catch (std::out_of_range& e) {
74932       {
74933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74934       };
74935     } catch (std::exception& e) {
74936       {
74937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74938       };
74939     } catch (...) {
74940       {
74941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74942       };
74943     }
74944   }
74945 }
74946
74947
74948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
74949   void * jresult ;
74950   Dali::Toolkit::TextLabel result;
74951
74952   {
74953     try {
74954       result = Dali::Toolkit::TextLabel::New();
74955     } catch (std::out_of_range& e) {
74956       {
74957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74958       };
74959     } catch (std::exception& e) {
74960       {
74961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74962       };
74963     } catch (...) {
74964       {
74965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74966       };
74967     }
74968   }
74969   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
74970   return jresult;
74971 }
74972
74973
74974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
74975   void * jresult ;
74976   std::string *arg1 = 0 ;
74977   Dali::Toolkit::TextLabel result;
74978
74979   if (!jarg1) {
74980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74981     return 0;
74982   }
74983   std::string arg1_str(jarg1);
74984   arg1 = &arg1_str;
74985   {
74986     try {
74987       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
74988     } catch (std::out_of_range& e) {
74989       {
74990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74991       };
74992     } catch (std::exception& e) {
74993       {
74994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74995       };
74996     } catch (...) {
74997       {
74998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74999       };
75000     }
75001   }
75002   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75003
75004   //argout typemap for const std::string&
75005
75006   return jresult;
75007 }
75008
75009
75010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
75011   void * jresult ;
75012   Dali::Toolkit::TextLabel *result = 0 ;
75013
75014   {
75015     try {
75016       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
75017     } catch (std::out_of_range& e) {
75018       {
75019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75020       };
75021     } catch (std::exception& e) {
75022       {
75023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75024       };
75025     } catch (...) {
75026       {
75027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75028       };
75029     }
75030   }
75031   jresult = (void *)result;
75032   return jresult;
75033 }
75034
75035
75036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
75037   void * jresult ;
75038   Dali::Toolkit::TextLabel *arg1 = 0 ;
75039   Dali::Toolkit::TextLabel *result = 0 ;
75040
75041   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75042   if (!arg1) {
75043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
75044     return 0;
75045   }
75046   {
75047     try {
75048       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
75049     } catch (std::out_of_range& e) {
75050       {
75051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75052       };
75053     } catch (std::exception& e) {
75054       {
75055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75056       };
75057     } catch (...) {
75058       {
75059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75060       };
75061     }
75062   }
75063   jresult = (void *)result;
75064   return jresult;
75065 }
75066
75067
75068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
75069   void * jresult ;
75070   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
75071   Dali::Toolkit::TextLabel *arg2 = 0 ;
75072   Dali::Toolkit::TextLabel *result = 0 ;
75073
75074   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75075   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
75076   if (!arg2) {
75077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
75078     return 0;
75079   }
75080   {
75081     try {
75082       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
75083     } catch (std::out_of_range& e) {
75084       {
75085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75086       };
75087     } catch (std::exception& e) {
75088       {
75089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75090       };
75091     } catch (...) {
75092       {
75093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75094       };
75095     }
75096   }
75097   jresult = (void *)result;
75098   return jresult;
75099 }
75100
75101
75102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
75103   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
75104
75105   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75106   {
75107     try {
75108       delete arg1;
75109     } catch (std::out_of_range& e) {
75110       {
75111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75112       };
75113     } catch (std::exception& e) {
75114       {
75115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75116       };
75117     } catch (...) {
75118       {
75119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75120       };
75121     }
75122   }
75123 }
75124
75125
75126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
75127   void * jresult ;
75128   Dali::BaseHandle arg1 ;
75129   Dali::BaseHandle *argp1 ;
75130   Dali::Toolkit::TextLabel result;
75131
75132   argp1 = (Dali::BaseHandle *)jarg1;
75133   if (!argp1) {
75134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75135     return 0;
75136   }
75137   arg1 = *argp1;
75138   {
75139     try {
75140       result = Dali::Toolkit::TextLabel::DownCast(arg1);
75141     } catch (std::out_of_range& e) {
75142       {
75143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75144       };
75145     } catch (std::exception& e) {
75146       {
75147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75148       };
75149     } catch (...) {
75150       {
75151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75152       };
75153     }
75154   }
75155   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75156   return jresult;
75157 }
75158
75159
75160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
75161   void * jresult ;
75162   Dali::Toolkit::AccessibilityManager *result = 0 ;
75163
75164   {
75165     try {
75166       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75174       };
75175     } catch (...) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75178       };
75179     }
75180   }
75181   jresult = (void *)result;
75182   return jresult;
75183 }
75184
75185
75186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
75187   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75188
75189   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75190   {
75191     try {
75192       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
75211   void * jresult ;
75212   Dali::Toolkit::AccessibilityManager result;
75213
75214   {
75215     try {
75216       result = Dali::Toolkit::AccessibilityManager::Get();
75217     } catch (std::out_of_range& e) {
75218       {
75219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75220       };
75221     } catch (std::exception& e) {
75222       {
75223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75224       };
75225     } catch (...) {
75226       {
75227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75228       };
75229     }
75230   }
75231   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
75232   return jresult;
75233 }
75234
75235
75236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
75237   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75238   Dali::Actor arg2 ;
75239   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
75240   std::string *arg4 = 0 ;
75241   Dali::Actor *argp2 ;
75242
75243   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75244   argp2 = (Dali::Actor *)jarg2;
75245   if (!argp2) {
75246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75247     return ;
75248   }
75249   arg2 = *argp2;
75250   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
75251   if (!jarg4) {
75252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75253     return ;
75254   }
75255   std::string arg4_str(jarg4);
75256   arg4 = &arg4_str;
75257   {
75258     try {
75259       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
75260     } catch (std::out_of_range& e) {
75261       {
75262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75263       };
75264     } catch (std::exception& e) {
75265       {
75266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75267       };
75268     } catch (...) {
75269       {
75270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75271       };
75272     }
75273   }
75274
75275   //argout typemap for const std::string&
75276
75277 }
75278
75279
75280 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
75281   char * jresult ;
75282   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75283   Dali::Actor arg2 ;
75284   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
75285   Dali::Actor *argp2 ;
75286   std::string result;
75287
75288   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75289   argp2 = (Dali::Actor *)jarg2;
75290   if (!argp2) {
75291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75292     return 0;
75293   }
75294   arg2 = *argp2;
75295   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
75296   {
75297     try {
75298       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
75299     } catch (std::out_of_range& e) {
75300       {
75301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75302       };
75303     } catch (std::exception& e) {
75304       {
75305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75306       };
75307     } catch (...) {
75308       {
75309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75310       };
75311     }
75312   }
75313   jresult = SWIG_csharp_string_callback((&result)->c_str());
75314   return jresult;
75315 }
75316
75317
75318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
75319   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75320   Dali::Actor arg2 ;
75321   unsigned int arg3 ;
75322   Dali::Actor *argp2 ;
75323
75324   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75325   argp2 = (Dali::Actor *)jarg2;
75326   if (!argp2) {
75327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75328     return ;
75329   }
75330   arg2 = *argp2;
75331   arg3 = (unsigned int)jarg3;
75332   {
75333     try {
75334       (arg1)->SetFocusOrder(arg2,arg3);
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (...) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75346       };
75347     }
75348   }
75349 }
75350
75351
75352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
75353   unsigned int jresult ;
75354   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75355   Dali::Actor arg2 ;
75356   Dali::Actor *argp2 ;
75357   unsigned int result;
75358
75359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75360   argp2 = (Dali::Actor *)jarg2;
75361   if (!argp2) {
75362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75363     return 0;
75364   }
75365   arg2 = *argp2;
75366   {
75367     try {
75368       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
75369     } catch (std::out_of_range& e) {
75370       {
75371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75372       };
75373     } catch (std::exception& e) {
75374       {
75375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75376       };
75377     } catch (...) {
75378       {
75379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75380       };
75381     }
75382   }
75383   jresult = result;
75384   return jresult;
75385 }
75386
75387
75388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
75389   unsigned int jresult ;
75390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75391   unsigned int result;
75392
75393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75394   {
75395     try {
75396       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
75397     } catch (std::out_of_range& e) {
75398       {
75399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75400       };
75401     } catch (std::exception& e) {
75402       {
75403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75404       };
75405     } catch (...) {
75406       {
75407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75408       };
75409     }
75410   }
75411   jresult = result;
75412   return jresult;
75413 }
75414
75415
75416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
75417   void * jresult ;
75418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75419   unsigned int arg2 ;
75420   Dali::Actor result;
75421
75422   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75423   arg2 = (unsigned int)jarg2;
75424   {
75425     try {
75426       result = (arg1)->GetActorByFocusOrder(arg2);
75427     } catch (std::out_of_range& e) {
75428       {
75429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75430       };
75431     } catch (std::exception& e) {
75432       {
75433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75434       };
75435     } catch (...) {
75436       {
75437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75438       };
75439     }
75440   }
75441   jresult = new Dali::Actor((const Dali::Actor &)result);
75442   return jresult;
75443 }
75444
75445
75446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
75447   unsigned int jresult ;
75448   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75449   Dali::Actor arg2 ;
75450   Dali::Actor *argp2 ;
75451   bool result;
75452
75453   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75454   argp2 = (Dali::Actor *)jarg2;
75455   if (!argp2) {
75456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75457     return 0;
75458   }
75459   arg2 = *argp2;
75460   {
75461     try {
75462       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
75463     } catch (std::out_of_range& e) {
75464       {
75465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75466       };
75467     } catch (std::exception& e) {
75468       {
75469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75470       };
75471     } catch (...) {
75472       {
75473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75474       };
75475     }
75476   }
75477   jresult = result;
75478   return jresult;
75479 }
75480
75481
75482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
75483   void * jresult ;
75484   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75485   Dali::Actor result;
75486
75487   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75488   {
75489     try {
75490       result = (arg1)->GetCurrentFocusActor();
75491     } catch (std::out_of_range& e) {
75492       {
75493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75494       };
75495     } catch (std::exception& e) {
75496       {
75497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75498       };
75499     } catch (...) {
75500       {
75501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75502       };
75503     }
75504   }
75505   jresult = new Dali::Actor((const Dali::Actor &)result);
75506   return jresult;
75507 }
75508
75509
75510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
75511   void * jresult ;
75512   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75513   Dali::Actor result;
75514
75515   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75516   {
75517     try {
75518       result = (arg1)->GetCurrentFocusGroup();
75519     } catch (std::out_of_range& e) {
75520       {
75521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75522       };
75523     } catch (std::exception& e) {
75524       {
75525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75526       };
75527     } catch (...) {
75528       {
75529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75530       };
75531     }
75532   }
75533   jresult = new Dali::Actor((const Dali::Actor &)result);
75534   return jresult;
75535 }
75536
75537
75538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
75539   unsigned int jresult ;
75540   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75541   unsigned int result;
75542
75543   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75544   {
75545     try {
75546       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
75547     } catch (std::out_of_range& e) {
75548       {
75549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75550       };
75551     } catch (std::exception& e) {
75552       {
75553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75554       };
75555     } catch (...) {
75556       {
75557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75558       };
75559     }
75560   }
75561   jresult = result;
75562   return jresult;
75563 }
75564
75565
75566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
75567   unsigned int jresult ;
75568   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75569   bool result;
75570
75571   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75572   {
75573     try {
75574       result = (bool)(arg1)->MoveFocusForward();
75575     } catch (std::out_of_range& e) {
75576       {
75577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75578       };
75579     } catch (std::exception& e) {
75580       {
75581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75582       };
75583     } catch (...) {
75584       {
75585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75586       };
75587     }
75588   }
75589   jresult = result;
75590   return jresult;
75591 }
75592
75593
75594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
75595   unsigned int jresult ;
75596   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75597   bool result;
75598
75599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75600   {
75601     try {
75602       result = (bool)(arg1)->MoveFocusBackward();
75603     } catch (std::out_of_range& e) {
75604       {
75605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75606       };
75607     } catch (std::exception& e) {
75608       {
75609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75610       };
75611     } catch (...) {
75612       {
75613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75614       };
75615     }
75616   }
75617   jresult = result;
75618   return jresult;
75619 }
75620
75621
75622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
75623   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75624
75625   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75626   {
75627     try {
75628       (arg1)->ClearFocus();
75629     } catch (std::out_of_range& e) {
75630       {
75631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75632       };
75633     } catch (std::exception& e) {
75634       {
75635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75636       };
75637     } catch (...) {
75638       {
75639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75640       };
75641     }
75642   }
75643 }
75644
75645
75646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
75647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75648
75649   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75650   {
75651     try {
75652       (arg1)->Reset();
75653     } catch (std::out_of_range& e) {
75654       {
75655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75656       };
75657     } catch (std::exception& e) {
75658       {
75659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75660       };
75661     } catch (...) {
75662       {
75663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75664       };
75665     }
75666   }
75667 }
75668
75669
75670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
75671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75672   Dali::Actor arg2 ;
75673   bool arg3 ;
75674   Dali::Actor *argp2 ;
75675
75676   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75677   argp2 = (Dali::Actor *)jarg2;
75678   if (!argp2) {
75679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75680     return ;
75681   }
75682   arg2 = *argp2;
75683   arg3 = jarg3 ? true : false;
75684   {
75685     try {
75686       (arg1)->SetFocusGroup(arg2,arg3);
75687     } catch (std::out_of_range& e) {
75688       {
75689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75690       };
75691     } catch (std::exception& e) {
75692       {
75693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75694       };
75695     } catch (...) {
75696       {
75697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75698       };
75699     }
75700   }
75701 }
75702
75703
75704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
75705   unsigned int jresult ;
75706   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75707   Dali::Actor arg2 ;
75708   Dali::Actor *argp2 ;
75709   bool result;
75710
75711   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75712   argp2 = (Dali::Actor *)jarg2;
75713   if (!argp2) {
75714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75715     return 0;
75716   }
75717   arg2 = *argp2;
75718   {
75719     try {
75720       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
75721     } catch (std::out_of_range& e) {
75722       {
75723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75724       };
75725     } catch (std::exception& e) {
75726       {
75727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75728       };
75729     } catch (...) {
75730       {
75731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75732       };
75733     }
75734   }
75735   jresult = result;
75736   return jresult;
75737 }
75738
75739
75740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
75741   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75742   bool arg2 ;
75743
75744   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75745   arg2 = jarg2 ? true : false;
75746   {
75747     try {
75748       (arg1)->SetGroupMode(arg2);
75749     } catch (std::out_of_range& e) {
75750       {
75751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75752       };
75753     } catch (std::exception& e) {
75754       {
75755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75756       };
75757     } catch (...) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75760       };
75761     }
75762   }
75763 }
75764
75765
75766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
75767   unsigned int jresult ;
75768   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75769   bool result;
75770
75771   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75772   {
75773     try {
75774       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
75775     } catch (std::out_of_range& e) {
75776       {
75777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75778       };
75779     } catch (std::exception& e) {
75780       {
75781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75782       };
75783     } catch (...) {
75784       {
75785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75786       };
75787     }
75788   }
75789   jresult = result;
75790   return jresult;
75791 }
75792
75793
75794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
75795   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75796   bool arg2 ;
75797
75798   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75799   arg2 = jarg2 ? true : false;
75800   {
75801     try {
75802       (arg1)->SetWrapMode(arg2);
75803     } catch (std::out_of_range& e) {
75804       {
75805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75806       };
75807     } catch (std::exception& e) {
75808       {
75809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75810       };
75811     } catch (...) {
75812       {
75813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75814       };
75815     }
75816   }
75817 }
75818
75819
75820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
75821   unsigned int jresult ;
75822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75823   bool result;
75824
75825   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75826   {
75827     try {
75828       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
75829     } catch (std::out_of_range& e) {
75830       {
75831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75832       };
75833     } catch (std::exception& e) {
75834       {
75835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75836       };
75837     } catch (...) {
75838       {
75839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75840       };
75841     }
75842   }
75843   jresult = result;
75844   return jresult;
75845 }
75846
75847
75848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
75849   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75850   Dali::Actor arg2 ;
75851   Dali::Actor *argp2 ;
75852
75853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75854   argp2 = (Dali::Actor *)jarg2;
75855   if (!argp2) {
75856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75857     return ;
75858   }
75859   arg2 = *argp2;
75860   {
75861     try {
75862       (arg1)->SetFocusIndicatorActor(arg2);
75863     } catch (std::out_of_range& e) {
75864       {
75865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75866       };
75867     } catch (std::exception& e) {
75868       {
75869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75870       };
75871     } catch (...) {
75872       {
75873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75874       };
75875     }
75876   }
75877 }
75878
75879
75880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
75881   void * jresult ;
75882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75883   Dali::Actor result;
75884
75885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75886   {
75887     try {
75888       result = (arg1)->GetFocusIndicatorActor();
75889     } catch (std::out_of_range& e) {
75890       {
75891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75892       };
75893     } catch (std::exception& e) {
75894       {
75895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75900       };
75901     }
75902   }
75903   jresult = new Dali::Actor((const Dali::Actor &)result);
75904   return jresult;
75905 }
75906
75907
75908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
75909   void * jresult ;
75910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75911   Dali::Actor arg2 ;
75912   Dali::Actor *argp2 ;
75913   Dali::Actor result;
75914
75915   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75916   argp2 = (Dali::Actor *)jarg2;
75917   if (!argp2) {
75918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75919     return 0;
75920   }
75921   arg2 = *argp2;
75922   {
75923     try {
75924       result = (arg1)->GetFocusGroup(arg2);
75925     } catch (std::out_of_range& e) {
75926       {
75927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75928       };
75929     } catch (std::exception& e) {
75930       {
75931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75932       };
75933     } catch (...) {
75934       {
75935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75936       };
75937     }
75938   }
75939   jresult = new Dali::Actor((const Dali::Actor &)result);
75940   return jresult;
75941 }
75942
75943
75944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
75945   void * jresult ;
75946   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75947   Dali::Vector2 result;
75948
75949   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75950   {
75951     try {
75952       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
75953     } catch (std::out_of_range& e) {
75954       {
75955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75956       };
75957     } catch (std::exception& e) {
75958       {
75959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75960       };
75961     } catch (...) {
75962       {
75963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75964       };
75965     }
75966   }
75967   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75968   return jresult;
75969 }
75970
75971
75972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
75973   void * jresult ;
75974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75975   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
75976
75977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75978   {
75979     try {
75980       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
75981     } catch (std::out_of_range& e) {
75982       {
75983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75984       };
75985     } catch (std::exception& e) {
75986       {
75987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75988       };
75989     } catch (...) {
75990       {
75991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75992       };
75993     }
75994   }
75995   jresult = (void *)result;
75996   return jresult;
75997 }
75998
75999
76000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
76001   void * jresult ;
76002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76003   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
76004
76005   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76006   {
76007     try {
76008       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
76009     } catch (std::out_of_range& e) {
76010       {
76011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76012       };
76013     } catch (std::exception& e) {
76014       {
76015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76016       };
76017     } catch (...) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76020       };
76021     }
76022   }
76023   jresult = (void *)result;
76024   return jresult;
76025 }
76026
76027
76028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
76029   void * jresult ;
76030   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76031   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
76032
76033   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76034   {
76035     try {
76036       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
76037     } catch (std::out_of_range& e) {
76038       {
76039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76040       };
76041     } catch (std::exception& e) {
76042       {
76043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76044       };
76045     } catch (...) {
76046       {
76047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76048       };
76049     }
76050   }
76051   jresult = (void *)result;
76052   return jresult;
76053 }
76054
76055
76056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
76057   void * jresult ;
76058   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76059   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76060
76061   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76062   {
76063     try {
76064       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
76065     } catch (std::out_of_range& e) {
76066       {
76067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76068       };
76069     } catch (std::exception& e) {
76070       {
76071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76072       };
76073     } catch (...) {
76074       {
76075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76076       };
76077     }
76078   }
76079   jresult = (void *)result;
76080   return jresult;
76081 }
76082
76083
76084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
76085   void * jresult ;
76086   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76087   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76088
76089   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76090   {
76091     try {
76092       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
76093     } catch (std::out_of_range& e) {
76094       {
76095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76096       };
76097     } catch (std::exception& e) {
76098       {
76099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76100       };
76101     } catch (...) {
76102       {
76103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76104       };
76105     }
76106   }
76107   jresult = (void *)result;
76108   return jresult;
76109 }
76110
76111
76112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
76113   void * jresult ;
76114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76115   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76116
76117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76118   {
76119     try {
76120       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
76121     } catch (std::out_of_range& e) {
76122       {
76123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76124       };
76125     } catch (std::exception& e) {
76126       {
76127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76128       };
76129     } catch (...) {
76130       {
76131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76132       };
76133     }
76134   }
76135   jresult = (void *)result;
76136   return jresult;
76137 }
76138
76139
76140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
76141   void * jresult ;
76142   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76143   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76144
76145   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76146   {
76147     try {
76148       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
76149     } catch (std::out_of_range& e) {
76150       {
76151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76152       };
76153     } catch (std::exception& e) {
76154       {
76155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76156       };
76157     } catch (...) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76160       };
76161     }
76162   }
76163   jresult = (void *)result;
76164   return jresult;
76165 }
76166
76167
76168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
76169   void * jresult ;
76170   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76171   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76172
76173   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76174   {
76175     try {
76176       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
76177     } catch (std::out_of_range& e) {
76178       {
76179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76180       };
76181     } catch (std::exception& e) {
76182       {
76183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76184       };
76185     } catch (...) {
76186       {
76187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76188       };
76189     }
76190   }
76191   jresult = (void *)result;
76192   return jresult;
76193 }
76194
76195
76196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
76197   void * jresult ;
76198   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76199   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76200
76201   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76202   {
76203     try {
76204       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
76205     } catch (std::out_of_range& e) {
76206       {
76207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76208       };
76209     } catch (std::exception& e) {
76210       {
76211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76212       };
76213     } catch (...) {
76214       {
76215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76216       };
76217     }
76218   }
76219   jresult = (void *)result;
76220   return jresult;
76221 }
76222
76223
76224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
76225   void * jresult ;
76226   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76227   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76228
76229   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76230   {
76231     try {
76232       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
76233     } catch (std::out_of_range& e) {
76234       {
76235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76236       };
76237     } catch (std::exception& e) {
76238       {
76239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76240       };
76241     } catch (...) {
76242       {
76243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76244       };
76245     }
76246   }
76247   jresult = (void *)result;
76248   return jresult;
76249 }
76250
76251
76252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
76253   void * jresult ;
76254   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76255   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76256
76257   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76258   {
76259     try {
76260       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
76261     } catch (std::out_of_range& e) {
76262       {
76263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76264       };
76265     } catch (std::exception& e) {
76266       {
76267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76268       };
76269     } catch (...) {
76270       {
76271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76272       };
76273     }
76274   }
76275   jresult = (void *)result;
76276   return jresult;
76277 }
76278
76279
76280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
76281   void * jresult ;
76282   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76283   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76284
76285   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76286   {
76287     try {
76288       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
76289     } catch (std::out_of_range& e) {
76290       {
76291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76292       };
76293     } catch (std::exception& e) {
76294       {
76295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76296       };
76297     } catch (...) {
76298       {
76299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76300       };
76301     }
76302   }
76303   jresult = (void *)result;
76304   return jresult;
76305 }
76306
76307
76308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
76309   void * jresult ;
76310   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76311   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76312
76313   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76314   {
76315     try {
76316       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
76317     } catch (std::out_of_range& e) {
76318       {
76319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76320       };
76321     } catch (std::exception& e) {
76322       {
76323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76324       };
76325     } catch (...) {
76326       {
76327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76328       };
76329     }
76330   }
76331   jresult = (void *)result;
76332   return jresult;
76333 }
76334
76335
76336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
76337   void * jresult ;
76338   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76339   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76340
76341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76342   {
76343     try {
76344       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
76345     } catch (std::out_of_range& e) {
76346       {
76347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76348       };
76349     } catch (std::exception& e) {
76350       {
76351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76352       };
76353     } catch (...) {
76354       {
76355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76356       };
76357     }
76358   }
76359   jresult = (void *)result;
76360   return jresult;
76361 }
76362
76363
76364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
76365   void * jresult ;
76366   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76367   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76368
76369   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76370   {
76371     try {
76372       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
76373     } catch (std::out_of_range& e) {
76374       {
76375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76376       };
76377     } catch (std::exception& e) {
76378       {
76379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76380       };
76381     } catch (...) {
76382       {
76383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76384       };
76385     }
76386   }
76387   jresult = (void *)result;
76388   return jresult;
76389 }
76390
76391
76392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
76393   void * jresult ;
76394   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76395   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76396
76397   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76398   {
76399     try {
76400       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
76401     } catch (std::out_of_range& e) {
76402       {
76403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76404       };
76405     } catch (std::exception& e) {
76406       {
76407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76408       };
76409     } catch (...) {
76410       {
76411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76412       };
76413     }
76414   }
76415   jresult = (void *)result;
76416   return jresult;
76417 }
76418
76419
76420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
76421   void * jresult ;
76422   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76423   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76424
76425   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76426   {
76427     try {
76428       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
76429     } catch (std::out_of_range& e) {
76430       {
76431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76432       };
76433     } catch (std::exception& e) {
76434       {
76435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76436       };
76437     } catch (...) {
76438       {
76439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76440       };
76441     }
76442   }
76443   jresult = (void *)result;
76444   return jresult;
76445 }
76446
76447
76448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
76449   void * jresult ;
76450   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76451   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76452
76453   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76454   {
76455     try {
76456       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
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_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
76477   void * jresult ;
76478   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76479   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76480
76481   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76482   {
76483     try {
76484       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
76485     } catch (std::out_of_range& e) {
76486       {
76487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76488       };
76489     } catch (std::exception& e) {
76490       {
76491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76492       };
76493     } catch (...) {
76494       {
76495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76496       };
76497     }
76498   }
76499   jresult = (void *)result;
76500   return jresult;
76501 }
76502
76503
76504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
76505   void * jresult ;
76506   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76507   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76508
76509   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76510   {
76511     try {
76512       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
76513     } catch (std::out_of_range& e) {
76514       {
76515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76516       };
76517     } catch (std::exception& e) {
76518       {
76519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76520       };
76521     } catch (...) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76524       };
76525     }
76526   }
76527   jresult = (void *)result;
76528   return jresult;
76529 }
76530
76531
76532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
76533   void * jresult ;
76534   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76535   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76536
76537   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76538   {
76539     try {
76540       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
76541     } catch (std::out_of_range& e) {
76542       {
76543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76544       };
76545     } catch (std::exception& e) {
76546       {
76547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76548       };
76549     } catch (...) {
76550       {
76551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76552       };
76553     }
76554   }
76555   jresult = (void *)result;
76556   return jresult;
76557 }
76558
76559
76560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
76561   void * jresult ;
76562   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76563   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76564
76565   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76566   {
76567     try {
76568       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
76569     } catch (std::out_of_range& e) {
76570       {
76571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76572       };
76573     } catch (std::exception& e) {
76574       {
76575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76576       };
76577     } catch (...) {
76578       {
76579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76580       };
76581     }
76582   }
76583   jresult = (void *)result;
76584   return jresult;
76585 }
76586
76587
76588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
76589   void * jresult ;
76590   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76591   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76592
76593   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76594   {
76595     try {
76596       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
76597     } catch (std::out_of_range& e) {
76598       {
76599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76600       };
76601     } catch (std::exception& e) {
76602       {
76603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76604       };
76605     } catch (...) {
76606       {
76607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76608       };
76609     }
76610   }
76611   jresult = (void *)result;
76612   return jresult;
76613 }
76614
76615
76616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
76617   void * jresult ;
76618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76619   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76620
76621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76622   {
76623     try {
76624       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
76625     } catch (std::out_of_range& e) {
76626       {
76627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76628       };
76629     } catch (std::exception& e) {
76630       {
76631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76632       };
76633     } catch (...) {
76634       {
76635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76636       };
76637     }
76638   }
76639   jresult = (void *)result;
76640   return jresult;
76641 }
76642
76643
76644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
76645   void * jresult ;
76646   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76647   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76648
76649   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76650   {
76651     try {
76652       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
76653     } catch (std::out_of_range& e) {
76654       {
76655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76656       };
76657     } catch (std::exception& e) {
76658       {
76659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76660       };
76661     } catch (...) {
76662       {
76663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76664       };
76665     }
76666   }
76667   jresult = (void *)result;
76668   return jresult;
76669 }
76670
76671
76672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
76673   void * jresult ;
76674   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76675   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76676
76677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76678   {
76679     try {
76680       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
76681     } catch (std::out_of_range& e) {
76682       {
76683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76684       };
76685     } catch (std::exception& e) {
76686       {
76687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76688       };
76689     } catch (...) {
76690       {
76691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76692       };
76693     }
76694   }
76695   jresult = (void *)result;
76696   return jresult;
76697 }
76698
76699
76700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
76701   void * jresult ;
76702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76703   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76704
76705   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76706   {
76707     try {
76708       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
76709     } catch (std::out_of_range& e) {
76710       {
76711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76712       };
76713     } catch (std::exception& e) {
76714       {
76715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76716       };
76717     } catch (...) {
76718       {
76719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76720       };
76721     }
76722   }
76723   jresult = (void *)result;
76724   return jresult;
76725 }
76726
76727
76728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
76729   void * jresult ;
76730   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76731   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76732
76733   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76734   {
76735     try {
76736       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
76737     } catch (std::out_of_range& e) {
76738       {
76739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76740       };
76741     } catch (std::exception& e) {
76742       {
76743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76744       };
76745     } catch (...) {
76746       {
76747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76748       };
76749     }
76750   }
76751   jresult = (void *)result;
76752   return jresult;
76753 }
76754
76755
76756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
76757   void * jresult ;
76758   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76759   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76760
76761   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76762   {
76763     try {
76764       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
76765     } catch (std::out_of_range& e) {
76766       {
76767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76768       };
76769     } catch (std::exception& e) {
76770       {
76771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76772       };
76773     } catch (...) {
76774       {
76775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76776       };
76777     }
76778   }
76779   jresult = (void *)result;
76780   return jresult;
76781 }
76782
76783
76784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
76785   void * jresult ;
76786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76787   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
76788
76789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76790   {
76791     try {
76792       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
76793     } catch (std::out_of_range& e) {
76794       {
76795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76796       };
76797     } catch (std::exception& e) {
76798       {
76799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76800       };
76801     } catch (...) {
76802       {
76803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76804       };
76805     }
76806   }
76807   jresult = (void *)result;
76808   return jresult;
76809 }
76810
76811
76812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
76813   void * jresult ;
76814   Dali::Toolkit::StyleManager *result = 0 ;
76815
76816   {
76817     try {
76818       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
76819     } catch (std::out_of_range& e) {
76820       {
76821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76822       };
76823     } catch (std::exception& e) {
76824       {
76825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76826       };
76827     } catch (...) {
76828       {
76829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76830       };
76831     }
76832   }
76833   jresult = (void *)result;
76834   return jresult;
76835 }
76836
76837
76838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
76839   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76840
76841   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76842   {
76843     try {
76844       delete arg1;
76845     } catch (std::out_of_range& e) {
76846       {
76847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76848       };
76849     } catch (std::exception& e) {
76850       {
76851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76852       };
76853     } catch (...) {
76854       {
76855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76856       };
76857     }
76858   }
76859 }
76860
76861
76862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
76863   void * jresult ;
76864   Dali::Toolkit::StyleManager result;
76865
76866   {
76867     try {
76868       result = Dali::Toolkit::StyleManager::Get();
76869     } catch (std::out_of_range& e) {
76870       {
76871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76872       };
76873     } catch (std::exception& e) {
76874       {
76875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76876       };
76877     } catch (...) {
76878       {
76879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76880       };
76881     }
76882   }
76883   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
76884   return jresult;
76885 }
76886
76887
76888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
76889   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76890   std::string *arg2 = 0 ;
76891
76892   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76893   if (!jarg2) {
76894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76895     return ;
76896   }
76897   std::string arg2_str(jarg2);
76898   arg2 = &arg2_str;
76899   {
76900     try {
76901       (arg1)->ApplyTheme((std::string const &)*arg2);
76902     } catch (std::out_of_range& e) {
76903       {
76904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76905       };
76906     } catch (std::exception& e) {
76907       {
76908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76909       };
76910     } catch (...) {
76911       {
76912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76913       };
76914     }
76915   }
76916
76917   //argout typemap for const std::string&
76918
76919 }
76920
76921
76922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
76923   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76924
76925   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76926   {
76927     try {
76928       (arg1)->ApplyDefaultTheme();
76929     } catch (std::out_of_range& e) {
76930       {
76931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76932       };
76933     } catch (std::exception& e) {
76934       {
76935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76936       };
76937     } catch (...) {
76938       {
76939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76940       };
76941     }
76942   }
76943 }
76944
76945
76946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
76947   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76948   std::string *arg2 = 0 ;
76949   Dali::Property::Value *arg3 = 0 ;
76950
76951   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76952   if (!jarg2) {
76953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76954     return ;
76955   }
76956   std::string arg2_str(jarg2);
76957   arg2 = &arg2_str;
76958   arg3 = (Dali::Property::Value *)jarg3;
76959   if (!arg3) {
76960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
76961     return ;
76962   }
76963   {
76964     try {
76965       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
76966     } catch (std::out_of_range& e) {
76967       {
76968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76969       };
76970     } catch (std::exception& e) {
76971       {
76972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76973       };
76974     } catch (...) {
76975       {
76976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76977       };
76978     }
76979   }
76980
76981   //argout typemap for const std::string&
76982
76983 }
76984
76985
76986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
76987   unsigned int jresult ;
76988   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76989   std::string *arg2 = 0 ;
76990   Dali::Property::Value *arg3 = 0 ;
76991   bool result;
76992
76993   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76994   if (!jarg2) {
76995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
76996     return 0;
76997   }
76998   std::string arg2_str(jarg2);
76999   arg2 = &arg2_str;
77000   arg3 = (Dali::Property::Value *)jarg3;
77001   if (!arg3) {
77002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
77003     return 0;
77004   }
77005   {
77006     try {
77007       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
77008     } catch (std::out_of_range& e) {
77009       {
77010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77011       };
77012     } catch (std::exception& e) {
77013       {
77014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77015       };
77016     } catch (...) {
77017       {
77018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77019       };
77020     }
77021   }
77022   jresult = result;
77023
77024   //argout typemap for const std::string&
77025
77026   return jresult;
77027 }
77028
77029
77030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
77031   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77032   Dali::Toolkit::Control arg2 ;
77033   std::string *arg3 = 0 ;
77034   std::string *arg4 = 0 ;
77035   Dali::Toolkit::Control *argp2 ;
77036
77037   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77038   argp2 = (Dali::Toolkit::Control *)jarg2;
77039   if (!argp2) {
77040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
77041     return ;
77042   }
77043   arg2 = *argp2;
77044   if (!jarg3) {
77045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77046     return ;
77047   }
77048   std::string arg3_str(jarg3);
77049   arg3 = &arg3_str;
77050   if (!jarg4) {
77051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77052     return ;
77053   }
77054   std::string arg4_str(jarg4);
77055   arg4 = &arg4_str;
77056   {
77057     try {
77058       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
77059     } catch (std::out_of_range& e) {
77060       {
77061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77062       };
77063     } catch (std::exception& e) {
77064       {
77065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77066       };
77067     } catch (...) {
77068       {
77069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77070       };
77071     }
77072   }
77073
77074   //argout typemap for const std::string&
77075
77076
77077   //argout typemap for const std::string&
77078
77079 }
77080
77081
77082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
77083   void * jresult ;
77084   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77085   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
77086
77087   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77088   {
77089     try {
77090       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
77091     } catch (std::out_of_range& e) {
77092       {
77093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77094       };
77095     } catch (std::exception& e) {
77096       {
77097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77098       };
77099     } catch (...) {
77100       {
77101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77102       };
77103     }
77104   }
77105   jresult = (void *)result;
77106   return jresult;
77107 }
77108
77109
77110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
77111   int jresult ;
77112   int result;
77113
77114   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
77115   jresult = (int)result;
77116   return jresult;
77117 }
77118
77119
77120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
77121   int jresult ;
77122   int result;
77123
77124   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
77125   jresult = (int)result;
77126   return jresult;
77127 }
77128
77129
77130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
77131   int jresult ;
77132   int result;
77133
77134   result = (int)Dali::Toolkit::Slider::Property::VALUE;
77135   jresult = (int)result;
77136   return jresult;
77137 }
77138
77139
77140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
77141   int jresult ;
77142   int result;
77143
77144   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
77145   jresult = (int)result;
77146   return jresult;
77147 }
77148
77149
77150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
77151   int jresult ;
77152   int result;
77153
77154   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
77155   jresult = (int)result;
77156   return jresult;
77157 }
77158
77159
77160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
77161   int jresult ;
77162   int result;
77163
77164   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
77165   jresult = (int)result;
77166   return jresult;
77167 }
77168
77169
77170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
77171   int jresult ;
77172   int result;
77173
77174   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
77175   jresult = (int)result;
77176   return jresult;
77177 }
77178
77179
77180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
77181   int jresult ;
77182   int result;
77183
77184   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
77185   jresult = (int)result;
77186   return jresult;
77187 }
77188
77189
77190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
77191   int jresult ;
77192   int result;
77193
77194   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
77195   jresult = (int)result;
77196   return jresult;
77197 }
77198
77199
77200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
77201   int jresult ;
77202   int result;
77203
77204   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
77205   jresult = (int)result;
77206   return jresult;
77207 }
77208
77209
77210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
77211   int jresult ;
77212   int result;
77213
77214   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
77215   jresult = (int)result;
77216   return jresult;
77217 }
77218
77219
77220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
77221   int jresult ;
77222   int result;
77223
77224   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
77225   jresult = (int)result;
77226   return jresult;
77227 }
77228
77229
77230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
77231   int jresult ;
77232   int result;
77233
77234   result = (int)Dali::Toolkit::Slider::Property::MARKS;
77235   jresult = (int)result;
77236   return jresult;
77237 }
77238
77239
77240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
77241   int jresult ;
77242   int result;
77243
77244   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
77245   jresult = (int)result;
77246   return jresult;
77247 }
77248
77249
77250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
77251   int jresult ;
77252   int result;
77253
77254   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
77255   jresult = (int)result;
77256   return jresult;
77257 }
77258
77259
77260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
77261   void * jresult ;
77262   Dali::Toolkit::Slider::Property *result = 0 ;
77263
77264   {
77265     try {
77266       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
77267     } catch (std::out_of_range& e) {
77268       {
77269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77270       };
77271     } catch (std::exception& e) {
77272       {
77273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77274       };
77275     } catch (...) {
77276       {
77277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77278       };
77279     }
77280   }
77281   jresult = (void *)result;
77282   return jresult;
77283 }
77284
77285
77286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
77287   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
77288
77289   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
77290   {
77291     try {
77292       delete arg1;
77293     } catch (std::out_of_range& e) {
77294       {
77295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77296       };
77297     } catch (std::exception& e) {
77298       {
77299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77300       };
77301     } catch (...) {
77302       {
77303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77304       };
77305     }
77306   }
77307 }
77308
77309
77310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
77311   void * jresult ;
77312   Dali::Toolkit::Slider result;
77313
77314   {
77315     try {
77316       result = Dali::Toolkit::Slider::New();
77317     } catch (std::out_of_range& e) {
77318       {
77319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77320       };
77321     } catch (std::exception& e) {
77322       {
77323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77324       };
77325     } catch (...) {
77326       {
77327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77328       };
77329     }
77330   }
77331   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
77332   return jresult;
77333 }
77334
77335
77336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
77337   void * jresult ;
77338   Dali::Toolkit::Slider *result = 0 ;
77339
77340   {
77341     try {
77342       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
77343     } catch (std::out_of_range& e) {
77344       {
77345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77346       };
77347     } catch (std::exception& e) {
77348       {
77349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77350       };
77351     } catch (...) {
77352       {
77353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77354       };
77355     }
77356   }
77357   jresult = (void *)result;
77358   return jresult;
77359 }
77360
77361
77362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
77363   void * jresult ;
77364   Dali::Toolkit::Slider *arg1 = 0 ;
77365   Dali::Toolkit::Slider *result = 0 ;
77366
77367   arg1 = (Dali::Toolkit::Slider *)jarg1;
77368   if (!arg1) {
77369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77370     return 0;
77371   }
77372   {
77373     try {
77374       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
77375     } catch (std::out_of_range& e) {
77376       {
77377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77378       };
77379     } catch (std::exception& e) {
77380       {
77381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77382       };
77383     } catch (...) {
77384       {
77385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77386       };
77387     }
77388   }
77389   jresult = (void *)result;
77390   return jresult;
77391 }
77392
77393
77394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
77395   void * jresult ;
77396   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77397   Dali::Toolkit::Slider *arg2 = 0 ;
77398   Dali::Toolkit::Slider *result = 0 ;
77399
77400   arg1 = (Dali::Toolkit::Slider *)jarg1;
77401   arg2 = (Dali::Toolkit::Slider *)jarg2;
77402   if (!arg2) {
77403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77404     return 0;
77405   }
77406   {
77407     try {
77408       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
77409     } catch (std::out_of_range& e) {
77410       {
77411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77412       };
77413     } catch (std::exception& e) {
77414       {
77415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77416       };
77417     } catch (...) {
77418       {
77419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77420       };
77421     }
77422   }
77423   jresult = (void *)result;
77424   return jresult;
77425 }
77426
77427
77428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
77429   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77430
77431   arg1 = (Dali::Toolkit::Slider *)jarg1;
77432   {
77433     try {
77434       delete arg1;
77435     } catch (std::out_of_range& e) {
77436       {
77437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77438       };
77439     } catch (std::exception& e) {
77440       {
77441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77442       };
77443     } catch (...) {
77444       {
77445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77446       };
77447     }
77448   }
77449 }
77450
77451
77452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
77453   void * jresult ;
77454   Dali::BaseHandle arg1 ;
77455   Dali::BaseHandle *argp1 ;
77456   Dali::Toolkit::Slider result;
77457
77458   argp1 = (Dali::BaseHandle *)jarg1;
77459   if (!argp1) {
77460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77461     return 0;
77462   }
77463   arg1 = *argp1;
77464   {
77465     try {
77466       result = Dali::Toolkit::Slider::DownCast(arg1);
77467     } catch (std::out_of_range& e) {
77468       {
77469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77470       };
77471     } catch (std::exception& e) {
77472       {
77473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77474       };
77475     } catch (...) {
77476       {
77477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77478       };
77479     }
77480   }
77481   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
77482   return jresult;
77483 }
77484
77485
77486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
77487   void * jresult ;
77488   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77489   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77490
77491   arg1 = (Dali::Toolkit::Slider *)jarg1;
77492   {
77493     try {
77494       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77495     } catch (std::out_of_range& e) {
77496       {
77497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77498       };
77499     } catch (std::exception& e) {
77500       {
77501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77502       };
77503     } catch (...) {
77504       {
77505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77506       };
77507     }
77508   }
77509   jresult = (void *)result;
77510   return jresult;
77511 }
77512
77513
77514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
77515   void * jresult ;
77516   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77517   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77518
77519   arg1 = (Dali::Toolkit::Slider *)jarg1;
77520   {
77521     try {
77522       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
77523     } catch (std::out_of_range& e) {
77524       {
77525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (std::exception& e) {
77528       {
77529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77530       };
77531     } catch (...) {
77532       {
77533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77534       };
77535     }
77536   }
77537   jresult = (void *)result;
77538   return jresult;
77539 }
77540
77541
77542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
77543   void * jresult ;
77544   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77545   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
77546
77547   arg1 = (Dali::Toolkit::Slider *)jarg1;
77548   {
77549     try {
77550       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
77551     } catch (std::out_of_range& e) {
77552       {
77553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77554       };
77555     } catch (std::exception& e) {
77556       {
77557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77558       };
77559     } catch (...) {
77560       {
77561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77562       };
77563     }
77564   }
77565   jresult = (void *)result;
77566   return jresult;
77567 }
77568
77569
77570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
77571   int jresult ;
77572   int result;
77573
77574   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
77575   jresult = (int)result;
77576   return jresult;
77577 }
77578
77579
77580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
77581   int jresult ;
77582   int result;
77583
77584   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
77585   jresult = (int)result;
77586   return jresult;
77587 }
77588
77589
77590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
77591   int jresult ;
77592   int result;
77593
77594   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
77595   jresult = (int)result;
77596   return jresult;
77597 }
77598
77599
77600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
77601   int jresult ;
77602   int result;
77603
77604   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
77605   jresult = (int)result;
77606   return jresult;
77607 }
77608
77609
77610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
77611   void * jresult ;
77612   Dali::Toolkit::VideoView::Property *result = 0 ;
77613
77614   {
77615     try {
77616       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
77617     } catch (std::out_of_range& e) {
77618       {
77619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77620       };
77621     } catch (std::exception& e) {
77622       {
77623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77624       };
77625     } catch (...) {
77626       {
77627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77628       };
77629     }
77630   }
77631   jresult = (void *)result;
77632   return jresult;
77633 }
77634
77635
77636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
77637   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
77638
77639   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
77640   {
77641     try {
77642       delete arg1;
77643     } catch (std::out_of_range& e) {
77644       {
77645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77646       };
77647     } catch (std::exception& e) {
77648       {
77649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77650       };
77651     } catch (...) {
77652       {
77653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77654       };
77655     }
77656   }
77657 }
77658
77659
77660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
77661   void * jresult ;
77662   Dali::Toolkit::VideoView result;
77663
77664   {
77665     try {
77666       result = Dali::Toolkit::VideoView::New();
77667     } catch (std::out_of_range& e) {
77668       {
77669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77670       };
77671     } catch (std::exception& e) {
77672       {
77673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77674       };
77675     } catch (...) {
77676       {
77677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77678       };
77679     }
77680   }
77681   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77682   return jresult;
77683 }
77684
77685
77686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
77687   void * jresult ;
77688   std::string *arg1 = 0 ;
77689   Dali::Toolkit::VideoView result;
77690
77691   if (!jarg1) {
77692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77693     return 0;
77694   }
77695   std::string arg1_str(jarg1);
77696   arg1 = &arg1_str;
77697   {
77698     try {
77699       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
77700     } catch (std::out_of_range& e) {
77701       {
77702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77703       };
77704     } catch (std::exception& e) {
77705       {
77706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77707       };
77708     } catch (...) {
77709       {
77710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77711       };
77712     }
77713   }
77714   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77715
77716   //argout typemap for const std::string&
77717
77718   return jresult;
77719 }
77720
77721
77722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
77723   void * jresult ;
77724   Dali::Toolkit::VideoView *result = 0 ;
77725
77726   {
77727     try {
77728       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
77729     } catch (std::out_of_range& e) {
77730       {
77731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77732       };
77733     } catch (std::exception& e) {
77734       {
77735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77736       };
77737     } catch (...) {
77738       {
77739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77740       };
77741     }
77742   }
77743   jresult = (void *)result;
77744   return jresult;
77745 }
77746
77747
77748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
77749   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77750
77751   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77752   {
77753     try {
77754       delete arg1;
77755     } catch (std::out_of_range& e) {
77756       {
77757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77758       };
77759     } catch (std::exception& e) {
77760       {
77761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77762       };
77763     } catch (...) {
77764       {
77765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77766       };
77767     }
77768   }
77769 }
77770
77771
77772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
77773   void * jresult ;
77774   Dali::Toolkit::VideoView *arg1 = 0 ;
77775   Dali::Toolkit::VideoView *result = 0 ;
77776
77777   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77778   if (!arg1) {
77779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77780     return 0;
77781   }
77782   {
77783     try {
77784       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
77785     } catch (std::out_of_range& e) {
77786       {
77787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77788       };
77789     } catch (std::exception& e) {
77790       {
77791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77792       };
77793     } catch (...) {
77794       {
77795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77796       };
77797     }
77798   }
77799   jresult = (void *)result;
77800   return jresult;
77801 }
77802
77803
77804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
77805   void * jresult ;
77806   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77807   Dali::Toolkit::VideoView *arg2 = 0 ;
77808   Dali::Toolkit::VideoView *result = 0 ;
77809
77810   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77811   arg2 = (Dali::Toolkit::VideoView *)jarg2;
77812   if (!arg2) {
77813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77814     return 0;
77815   }
77816   {
77817     try {
77818       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
77819     } catch (std::out_of_range& e) {
77820       {
77821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77822       };
77823     } catch (std::exception& e) {
77824       {
77825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77826       };
77827     } catch (...) {
77828       {
77829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77830       };
77831     }
77832   }
77833   jresult = (void *)result;
77834   return jresult;
77835 }
77836
77837
77838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
77839   void * jresult ;
77840   Dali::BaseHandle arg1 ;
77841   Dali::BaseHandle *argp1 ;
77842   Dali::Toolkit::VideoView result;
77843
77844   argp1 = (Dali::BaseHandle *)jarg1;
77845   if (!argp1) {
77846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77847     return 0;
77848   }
77849   arg1 = *argp1;
77850   {
77851     try {
77852       result = Dali::Toolkit::VideoView::DownCast(arg1);
77853     } catch (std::out_of_range& e) {
77854       {
77855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77856       };
77857     } catch (std::exception& e) {
77858       {
77859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77860       };
77861     } catch (...) {
77862       {
77863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77864       };
77865     }
77866   }
77867   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77868   return jresult;
77869 }
77870
77871
77872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
77873   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77874
77875   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77876   {
77877     try {
77878       (arg1)->Play();
77879     } catch (std::out_of_range& e) {
77880       {
77881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77882       };
77883     } catch (std::exception& e) {
77884       {
77885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77886       };
77887     } catch (...) {
77888       {
77889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77890       };
77891     }
77892   }
77893 }
77894
77895
77896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
77897   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77898
77899   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77900   {
77901     try {
77902       (arg1)->Pause();
77903     } catch (std::out_of_range& e) {
77904       {
77905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77906       };
77907     } catch (std::exception& e) {
77908       {
77909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77910       };
77911     } catch (...) {
77912       {
77913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77914       };
77915     }
77916   }
77917 }
77918
77919
77920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
77921   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77922
77923   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77924   {
77925     try {
77926       (arg1)->Stop();
77927     } catch (std::out_of_range& e) {
77928       {
77929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77930       };
77931     } catch (std::exception& e) {
77932       {
77933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77934       };
77935     } catch (...) {
77936       {
77937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77938       };
77939     }
77940   }
77941 }
77942
77943
77944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
77945   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77946   int arg2 ;
77947
77948   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77949   arg2 = (int)jarg2;
77950   {
77951     try {
77952       (arg1)->Forward(arg2);
77953     } catch (std::out_of_range& e) {
77954       {
77955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77956       };
77957     } catch (std::exception& e) {
77958       {
77959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77960       };
77961     } catch (...) {
77962       {
77963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77964       };
77965     }
77966   }
77967 }
77968
77969
77970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
77971   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77972   int arg2 ;
77973
77974   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77975   arg2 = (int)jarg2;
77976   {
77977     try {
77978       (arg1)->Backward(arg2);
77979     } catch (std::out_of_range& e) {
77980       {
77981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77982       };
77983     } catch (std::exception& e) {
77984       {
77985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77986       };
77987     } catch (...) {
77988       {
77989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77990       };
77991     }
77992   }
77993 }
77994
77995
77996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
77997   void * jresult ;
77998   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77999   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
78000
78001   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78002   {
78003     try {
78004       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
78005     } catch (std::out_of_range& e) {
78006       {
78007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (std::exception& e) {
78010       {
78011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78012       };
78013     } catch (...) {
78014       {
78015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78016       };
78017     }
78018   }
78019   jresult = (void *)result;
78020   return jresult;
78021 }
78022
78023
78024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
78025   int jresult ;
78026   int result;
78027
78028   result = (int)Dali::Toolkit::Popup::Property::TITLE;
78029   jresult = (int)result;
78030   return jresult;
78031 }
78032
78033
78034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
78035   int jresult ;
78036   int result;
78037
78038   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
78039   jresult = (int)result;
78040   return jresult;
78041 }
78042
78043
78044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
78045   int jresult ;
78046   int result;
78047
78048   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
78049   jresult = (int)result;
78050   return jresult;
78051 }
78052
78053
78054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
78055   int jresult ;
78056   int result;
78057
78058   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
78059   jresult = (int)result;
78060   return jresult;
78061 }
78062
78063
78064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
78065   int jresult ;
78066   int result;
78067
78068   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
78069   jresult = (int)result;
78070   return jresult;
78071 }
78072
78073
78074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
78075   int jresult ;
78076   int result;
78077
78078   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
78079   jresult = (int)result;
78080   return jresult;
78081 }
78082
78083
78084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
78085   int jresult ;
78086   int result;
78087
78088   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
78089   jresult = (int)result;
78090   return jresult;
78091 }
78092
78093
78094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
78095   int jresult ;
78096   int result;
78097
78098   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
78099   jresult = (int)result;
78100   return jresult;
78101 }
78102
78103
78104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
78105   int jresult ;
78106   int result;
78107
78108   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
78109   jresult = (int)result;
78110   return jresult;
78111 }
78112
78113
78114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
78115   int jresult ;
78116   int result;
78117
78118   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
78119   jresult = (int)result;
78120   return jresult;
78121 }
78122
78123
78124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
78125   int jresult ;
78126   int result;
78127
78128   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
78129   jresult = (int)result;
78130   return jresult;
78131 }
78132
78133
78134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
78135   int jresult ;
78136   int result;
78137
78138   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
78139   jresult = (int)result;
78140   return jresult;
78141 }
78142
78143
78144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
78145   int jresult ;
78146   int result;
78147
78148   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
78149   jresult = (int)result;
78150   return jresult;
78151 }
78152
78153
78154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
78155   int jresult ;
78156   int result;
78157
78158   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
78159   jresult = (int)result;
78160   return jresult;
78161 }
78162
78163
78164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
78165   int jresult ;
78166   int result;
78167
78168   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
78169   jresult = (int)result;
78170   return jresult;
78171 }
78172
78173
78174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
78175   int jresult ;
78176   int result;
78177
78178   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
78179   jresult = (int)result;
78180   return jresult;
78181 }
78182
78183
78184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
78185   int jresult ;
78186   int result;
78187
78188   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
78189   jresult = (int)result;
78190   return jresult;
78191 }
78192
78193
78194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
78195   int jresult ;
78196   int result;
78197
78198   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
78199   jresult = (int)result;
78200   return jresult;
78201 }
78202
78203
78204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
78205   int jresult ;
78206   int result;
78207
78208   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
78209   jresult = (int)result;
78210   return jresult;
78211 }
78212
78213
78214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
78215   int jresult ;
78216   int result;
78217
78218   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
78219   jresult = (int)result;
78220   return jresult;
78221 }
78222
78223
78224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
78225   int jresult ;
78226   int result;
78227
78228   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
78229   jresult = (int)result;
78230   return jresult;
78231 }
78232
78233
78234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
78235   void * jresult ;
78236   Dali::Toolkit::Popup::Property *result = 0 ;
78237
78238   {
78239     try {
78240       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
78241     } catch (std::out_of_range& e) {
78242       {
78243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78244       };
78245     } catch (std::exception& e) {
78246       {
78247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78248       };
78249     } catch (...) {
78250       {
78251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78252       };
78253     }
78254   }
78255   jresult = (void *)result;
78256   return jresult;
78257 }
78258
78259
78260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
78261   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
78262
78263   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
78264   {
78265     try {
78266       delete arg1;
78267     } catch (std::out_of_range& e) {
78268       {
78269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78270       };
78271     } catch (std::exception& e) {
78272       {
78273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78274       };
78275     } catch (...) {
78276       {
78277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78278       };
78279     }
78280   }
78281 }
78282
78283
78284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
78285   void * jresult ;
78286   Dali::Toolkit::Popup *result = 0 ;
78287
78288   {
78289     try {
78290       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
78291     } catch (std::out_of_range& e) {
78292       {
78293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78294       };
78295     } catch (std::exception& e) {
78296       {
78297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78298       };
78299     } catch (...) {
78300       {
78301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78302       };
78303     }
78304   }
78305   jresult = (void *)result;
78306   return jresult;
78307 }
78308
78309
78310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
78311   void * jresult ;
78312   Dali::Toolkit::Popup result;
78313
78314   {
78315     try {
78316       result = Dali::Toolkit::Popup::New();
78317     } catch (std::out_of_range& e) {
78318       {
78319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78320       };
78321     } catch (std::exception& e) {
78322       {
78323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78324       };
78325     } catch (...) {
78326       {
78327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78328       };
78329     }
78330   }
78331   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
78332   return jresult;
78333 }
78334
78335
78336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
78337   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78338
78339   arg1 = (Dali::Toolkit::Popup *)jarg1;
78340   {
78341     try {
78342       delete arg1;
78343     } catch (std::out_of_range& e) {
78344       {
78345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78346       };
78347     } catch (std::exception& e) {
78348       {
78349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78350       };
78351     } catch (...) {
78352       {
78353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78354       };
78355     }
78356   }
78357 }
78358
78359
78360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
78361   void * jresult ;
78362   Dali::Toolkit::Popup *arg1 = 0 ;
78363   Dali::Toolkit::Popup *result = 0 ;
78364
78365   arg1 = (Dali::Toolkit::Popup *)jarg1;
78366   if (!arg1) {
78367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78368     return 0;
78369   }
78370   {
78371     try {
78372       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
78373     } catch (std::out_of_range& e) {
78374       {
78375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78376       };
78377     } catch (std::exception& e) {
78378       {
78379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78380       };
78381     } catch (...) {
78382       {
78383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78384       };
78385     }
78386   }
78387   jresult = (void *)result;
78388   return jresult;
78389 }
78390
78391
78392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
78393   void * jresult ;
78394   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78395   Dali::Toolkit::Popup *arg2 = 0 ;
78396   Dali::Toolkit::Popup *result = 0 ;
78397
78398   arg1 = (Dali::Toolkit::Popup *)jarg1;
78399   arg2 = (Dali::Toolkit::Popup *)jarg2;
78400   if (!arg2) {
78401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78402     return 0;
78403   }
78404   {
78405     try {
78406       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
78407     } catch (std::out_of_range& e) {
78408       {
78409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78410       };
78411     } catch (std::exception& e) {
78412       {
78413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78414       };
78415     } catch (...) {
78416       {
78417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78418       };
78419     }
78420   }
78421   jresult = (void *)result;
78422   return jresult;
78423 }
78424
78425
78426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
78427   void * jresult ;
78428   Dali::BaseHandle arg1 ;
78429   Dali::BaseHandle *argp1 ;
78430   Dali::Toolkit::Popup result;
78431
78432   argp1 = (Dali::BaseHandle *)jarg1;
78433   if (!argp1) {
78434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78435     return 0;
78436   }
78437   arg1 = *argp1;
78438   {
78439     try {
78440       result = Dali::Toolkit::Popup::DownCast(arg1);
78441     } catch (std::out_of_range& e) {
78442       {
78443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78444       };
78445     } catch (std::exception& e) {
78446       {
78447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78452       };
78453     }
78454   }
78455   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
78456   return jresult;
78457 }
78458
78459
78460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
78461   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78462   Dali::Actor arg2 ;
78463   Dali::Actor *argp2 ;
78464
78465   arg1 = (Dali::Toolkit::Popup *)jarg1;
78466   argp2 = (Dali::Actor *)jarg2;
78467   if (!argp2) {
78468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78469     return ;
78470   }
78471   arg2 = *argp2;
78472   {
78473     try {
78474       (arg1)->SetTitle(arg2);
78475     } catch (std::out_of_range& e) {
78476       {
78477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78478       };
78479     } catch (std::exception& e) {
78480       {
78481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78482       };
78483     } catch (...) {
78484       {
78485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78486       };
78487     }
78488   }
78489 }
78490
78491
78492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
78493   void * jresult ;
78494   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78495   Dali::Actor result;
78496
78497   arg1 = (Dali::Toolkit::Popup *)jarg1;
78498   {
78499     try {
78500       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
78501     } catch (std::out_of_range& e) {
78502       {
78503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78504       };
78505     } catch (std::exception& e) {
78506       {
78507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78508       };
78509     } catch (...) {
78510       {
78511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78512       };
78513     }
78514   }
78515   jresult = new Dali::Actor((const Dali::Actor &)result);
78516   return jresult;
78517 }
78518
78519
78520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
78521   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78522   Dali::Actor arg2 ;
78523   Dali::Actor *argp2 ;
78524
78525   arg1 = (Dali::Toolkit::Popup *)jarg1;
78526   argp2 = (Dali::Actor *)jarg2;
78527   if (!argp2) {
78528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78529     return ;
78530   }
78531   arg2 = *argp2;
78532   {
78533     try {
78534       (arg1)->SetContent(arg2);
78535     } catch (std::out_of_range& e) {
78536       {
78537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78538       };
78539     } catch (std::exception& e) {
78540       {
78541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78542       };
78543     } catch (...) {
78544       {
78545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78546       };
78547     }
78548   }
78549 }
78550
78551
78552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
78553   void * jresult ;
78554   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78555   Dali::Actor result;
78556
78557   arg1 = (Dali::Toolkit::Popup *)jarg1;
78558   {
78559     try {
78560       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
78561     } catch (std::out_of_range& e) {
78562       {
78563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78564       };
78565     } catch (std::exception& e) {
78566       {
78567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78568       };
78569     } catch (...) {
78570       {
78571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78572       };
78573     }
78574   }
78575   jresult = new Dali::Actor((const Dali::Actor &)result);
78576   return jresult;
78577 }
78578
78579
78580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
78581   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78582   Dali::Actor arg2 ;
78583   Dali::Actor *argp2 ;
78584
78585   arg1 = (Dali::Toolkit::Popup *)jarg1;
78586   argp2 = (Dali::Actor *)jarg2;
78587   if (!argp2) {
78588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78589     return ;
78590   }
78591   arg2 = *argp2;
78592   {
78593     try {
78594       (arg1)->SetFooter(arg2);
78595     } catch (std::out_of_range& e) {
78596       {
78597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78598       };
78599     } catch (std::exception& e) {
78600       {
78601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78602       };
78603     } catch (...) {
78604       {
78605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78606       };
78607     }
78608   }
78609 }
78610
78611
78612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
78613   void * jresult ;
78614   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78615   Dali::Actor result;
78616
78617   arg1 = (Dali::Toolkit::Popup *)jarg1;
78618   {
78619     try {
78620       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
78621     } catch (std::out_of_range& e) {
78622       {
78623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78624       };
78625     } catch (std::exception& e) {
78626       {
78627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78628       };
78629     } catch (...) {
78630       {
78631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78632       };
78633     }
78634   }
78635   jresult = new Dali::Actor((const Dali::Actor &)result);
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
78641   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78642   Dali::Toolkit::Popup::DisplayState arg2 ;
78643
78644   arg1 = (Dali::Toolkit::Popup *)jarg1;
78645   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
78646   {
78647     try {
78648       (arg1)->SetDisplayState(arg2);
78649     } catch (std::out_of_range& e) {
78650       {
78651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78652       };
78653     } catch (std::exception& e) {
78654       {
78655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78656       };
78657     } catch (...) {
78658       {
78659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78660       };
78661     }
78662   }
78663 }
78664
78665
78666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
78667   int jresult ;
78668   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78669   Dali::Toolkit::Popup::DisplayState result;
78670
78671   arg1 = (Dali::Toolkit::Popup *)jarg1;
78672   {
78673     try {
78674       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
78675     } catch (std::out_of_range& e) {
78676       {
78677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78678       };
78679     } catch (std::exception& e) {
78680       {
78681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78682       };
78683     } catch (...) {
78684       {
78685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78686       };
78687     }
78688   }
78689   jresult = (int)result;
78690   return jresult;
78691 }
78692
78693
78694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
78695   void * jresult ;
78696   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78697   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
78698
78699   arg1 = (Dali::Toolkit::Popup *)jarg1;
78700   {
78701     try {
78702       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
78703     } catch (std::out_of_range& e) {
78704       {
78705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78706       };
78707     } catch (std::exception& e) {
78708       {
78709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78710       };
78711     } catch (...) {
78712       {
78713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78714       };
78715     }
78716   }
78717   jresult = (void *)result;
78718   return jresult;
78719 }
78720
78721
78722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
78723   void * jresult ;
78724   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78725   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78726
78727   arg1 = (Dali::Toolkit::Popup *)jarg1;
78728   {
78729     try {
78730       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
78731     } catch (std::out_of_range& e) {
78732       {
78733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78734       };
78735     } catch (std::exception& e) {
78736       {
78737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78738       };
78739     } catch (...) {
78740       {
78741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78742       };
78743     }
78744   }
78745   jresult = (void *)result;
78746   return jresult;
78747 }
78748
78749
78750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
78751   void * jresult ;
78752   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78753   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78754
78755   arg1 = (Dali::Toolkit::Popup *)jarg1;
78756   {
78757     try {
78758       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
78759     } catch (std::out_of_range& e) {
78760       {
78761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78762       };
78763     } catch (std::exception& e) {
78764       {
78765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78766       };
78767     } catch (...) {
78768       {
78769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78770       };
78771     }
78772   }
78773   jresult = (void *)result;
78774   return jresult;
78775 }
78776
78777
78778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
78779   void * jresult ;
78780   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78781   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78782
78783   arg1 = (Dali::Toolkit::Popup *)jarg1;
78784   {
78785     try {
78786       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
78787     } catch (std::out_of_range& e) {
78788       {
78789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78790       };
78791     } catch (std::exception& e) {
78792       {
78793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78794       };
78795     } catch (...) {
78796       {
78797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78798       };
78799     }
78800   }
78801   jresult = (void *)result;
78802   return jresult;
78803 }
78804
78805
78806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
78807   void * jresult ;
78808   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78809   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78810
78811   arg1 = (Dali::Toolkit::Popup *)jarg1;
78812   {
78813     try {
78814       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
78815     } catch (std::out_of_range& e) {
78816       {
78817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78818       };
78819     } catch (std::exception& e) {
78820       {
78821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78822       };
78823     } catch (...) {
78824       {
78825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78826       };
78827     }
78828   }
78829   jresult = (void *)result;
78830   return jresult;
78831 }
78832
78833
78834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
78835   int jresult ;
78836   int result;
78837
78838   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
78839   jresult = (int)result;
78840   return jresult;
78841 }
78842
78843
78844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
78845   int jresult ;
78846   int result;
78847
78848   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
78849   jresult = (int)result;
78850   return jresult;
78851 }
78852
78853
78854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
78855   int jresult ;
78856   int result;
78857
78858   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
78859   jresult = (int)result;
78860   return jresult;
78861 }
78862
78863
78864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
78865   int jresult ;
78866   int result;
78867
78868   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
78869   jresult = (int)result;
78870   return jresult;
78871 }
78872
78873
78874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
78875   int jresult ;
78876   int result;
78877
78878   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
78879   jresult = (int)result;
78880   return jresult;
78881 }
78882
78883
78884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
78885   int jresult ;
78886   int result;
78887
78888   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
78889   jresult = (int)result;
78890   return jresult;
78891 }
78892
78893
78894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
78895   int jresult ;
78896   int result;
78897
78898   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
78899   jresult = (int)result;
78900   return jresult;
78901 }
78902
78903
78904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
78905   int jresult ;
78906   int result;
78907
78908   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
78909   jresult = (int)result;
78910   return jresult;
78911 }
78912
78913
78914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
78915   int jresult ;
78916   int result;
78917
78918   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
78919   jresult = (int)result;
78920   return jresult;
78921 }
78922
78923
78924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
78925   void * jresult ;
78926   Dali::Toolkit::ProgressBar::Property *result = 0 ;
78927
78928   {
78929     try {
78930       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
78931     } catch (std::out_of_range& e) {
78932       {
78933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78934       };
78935     } catch (std::exception& e) {
78936       {
78937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (...) {
78940       {
78941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78942       };
78943     }
78944   }
78945   jresult = (void *)result;
78946   return jresult;
78947 }
78948
78949
78950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
78951   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
78952
78953   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
78954   {
78955     try {
78956       delete arg1;
78957     } catch (std::out_of_range& e) {
78958       {
78959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78960       };
78961     } catch (std::exception& e) {
78962       {
78963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78964       };
78965     } catch (...) {
78966       {
78967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78968       };
78969     }
78970   }
78971 }
78972
78973
78974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
78975   void * jresult ;
78976   Dali::Toolkit::ProgressBar result;
78977
78978   {
78979     try {
78980       result = Dali::Toolkit::ProgressBar::New();
78981     } catch (std::out_of_range& e) {
78982       {
78983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78984       };
78985     } catch (std::exception& e) {
78986       {
78987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (...) {
78990       {
78991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78992       };
78993     }
78994   }
78995   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
78996   return jresult;
78997 }
78998
78999
79000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
79001   void * jresult ;
79002   Dali::Toolkit::ProgressBar *result = 0 ;
79003
79004   {
79005     try {
79006       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
79007     } catch (std::out_of_range& e) {
79008       {
79009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79010       };
79011     } catch (std::exception& e) {
79012       {
79013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79014       };
79015     } catch (...) {
79016       {
79017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79018       };
79019     }
79020   }
79021   jresult = (void *)result;
79022   return jresult;
79023 }
79024
79025
79026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
79027   void * jresult ;
79028   Dali::Toolkit::ProgressBar *arg1 = 0 ;
79029   Dali::Toolkit::ProgressBar *result = 0 ;
79030
79031   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79032   if (!arg1) {
79033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
79034     return 0;
79035   }
79036   {
79037     try {
79038       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
79039     } catch (std::out_of_range& e) {
79040       {
79041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79042       };
79043     } catch (std::exception& e) {
79044       {
79045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79046       };
79047     } catch (...) {
79048       {
79049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79050       };
79051     }
79052   }
79053   jresult = (void *)result;
79054   return jresult;
79055 }
79056
79057
79058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
79059   void * jresult ;
79060   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79061   Dali::Toolkit::ProgressBar *arg2 = 0 ;
79062   Dali::Toolkit::ProgressBar *result = 0 ;
79063
79064   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79065   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
79066   if (!arg2) {
79067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
79068     return 0;
79069   }
79070   {
79071     try {
79072       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
79073     } catch (std::out_of_range& e) {
79074       {
79075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79076       };
79077     } catch (std::exception& e) {
79078       {
79079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79080       };
79081     } catch (...) {
79082       {
79083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79084       };
79085     }
79086   }
79087   jresult = (void *)result;
79088   return jresult;
79089 }
79090
79091
79092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
79093   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79094
79095   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79096   {
79097     try {
79098       delete arg1;
79099     } catch (std::out_of_range& e) {
79100       {
79101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79102       };
79103     } catch (std::exception& e) {
79104       {
79105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79106       };
79107     } catch (...) {
79108       {
79109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79110       };
79111     }
79112   }
79113 }
79114
79115
79116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
79117   void * jresult ;
79118   Dali::BaseHandle arg1 ;
79119   Dali::BaseHandle *argp1 ;
79120   Dali::Toolkit::ProgressBar result;
79121
79122   argp1 = (Dali::BaseHandle *)jarg1;
79123   if (!argp1) {
79124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79125     return 0;
79126   }
79127   arg1 = *argp1;
79128   {
79129     try {
79130       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
79131     } catch (std::out_of_range& e) {
79132       {
79133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79134       };
79135     } catch (std::exception& e) {
79136       {
79137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79138       };
79139     } catch (...) {
79140       {
79141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79142       };
79143     }
79144   }
79145   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
79146   return jresult;
79147 }
79148
79149
79150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
79151   void * jresult ;
79152   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79153   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
79154
79155   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79156   {
79157     try {
79158       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
79159     } catch (std::out_of_range& e) {
79160       {
79161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79162       };
79163     } catch (std::exception& e) {
79164       {
79165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (...) {
79168       {
79169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79170       };
79171     }
79172   }
79173   jresult = (void *)result;
79174   return jresult;
79175 }
79176
79177
79178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
79179   void * jresult ;
79180   Dali::Toolkit::GaussianBlurView *result = 0 ;
79181
79182   {
79183     try {
79184       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
79185     } catch (std::out_of_range& e) {
79186       {
79187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79188       };
79189     } catch (std::exception& e) {
79190       {
79191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79192       };
79193     } catch (...) {
79194       {
79195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79196       };
79197     }
79198   }
79199   jresult = (void *)result;
79200   return jresult;
79201 }
79202
79203
79204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
79205   void * jresult ;
79206   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
79207   Dali::Toolkit::GaussianBlurView *result = 0 ;
79208
79209   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79210   if (!arg1) {
79211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
79212     return 0;
79213   }
79214   {
79215     try {
79216       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
79217     } catch (std::out_of_range& e) {
79218       {
79219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79220       };
79221     } catch (std::exception& e) {
79222       {
79223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79224       };
79225     } catch (...) {
79226       {
79227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79228       };
79229     }
79230   }
79231   jresult = (void *)result;
79232   return jresult;
79233 }
79234
79235
79236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
79237   void * jresult ;
79238   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79239   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
79240   Dali::Toolkit::GaussianBlurView *result = 0 ;
79241
79242   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79243   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
79244   if (!arg2) {
79245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
79246     return 0;
79247   }
79248   {
79249     try {
79250       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
79251     } catch (std::out_of_range& e) {
79252       {
79253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79254       };
79255     } catch (std::exception& e) {
79256       {
79257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (...) {
79260       {
79261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79262       };
79263     }
79264   }
79265   jresult = (void *)result;
79266   return jresult;
79267 }
79268
79269
79270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
79271   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79272
79273   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79274   {
79275     try {
79276       delete arg1;
79277     } catch (std::out_of_range& e) {
79278       {
79279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79280       };
79281     } catch (std::exception& e) {
79282       {
79283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79284       };
79285     } catch (...) {
79286       {
79287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79288       };
79289     }
79290   }
79291 }
79292
79293
79294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
79295   void * jresult ;
79296   Dali::BaseHandle arg1 ;
79297   Dali::BaseHandle *argp1 ;
79298   Dali::Toolkit::GaussianBlurView result;
79299
79300   argp1 = (Dali::BaseHandle *)jarg1;
79301   if (!argp1) {
79302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79303     return 0;
79304   }
79305   arg1 = *argp1;
79306   {
79307     try {
79308       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
79309     } catch (std::out_of_range& e) {
79310       {
79311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79312       };
79313     } catch (std::exception& e) {
79314       {
79315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79316       };
79317     } catch (...) {
79318       {
79319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79320       };
79321     }
79322   }
79323   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79324   return jresult;
79325 }
79326
79327
79328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
79329   void * jresult ;
79330   Dali::Toolkit::GaussianBlurView result;
79331
79332   {
79333     try {
79334       result = Dali::Toolkit::GaussianBlurView::New();
79335     } catch (std::out_of_range& e) {
79336       {
79337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79338       };
79339     } catch (std::exception& e) {
79340       {
79341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79342       };
79343     } catch (...) {
79344       {
79345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79346       };
79347     }
79348   }
79349   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
79355   void * jresult ;
79356   unsigned int arg1 ;
79357   float arg2 ;
79358   Dali::Pixel::Format arg3 ;
79359   float arg4 ;
79360   float arg5 ;
79361   bool arg6 ;
79362   Dali::Toolkit::GaussianBlurView result;
79363
79364   arg1 = (unsigned int)jarg1;
79365   arg2 = (float)jarg2;
79366   arg3 = (Dali::Pixel::Format)jarg3;
79367   arg4 = (float)jarg4;
79368   arg5 = (float)jarg5;
79369   arg6 = jarg6 ? true : false;
79370   {
79371     try {
79372       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
79373     } catch (std::out_of_range& e) {
79374       {
79375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79376       };
79377     } catch (std::exception& e) {
79378       {
79379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79380       };
79381     } catch (...) {
79382       {
79383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79384       };
79385     }
79386   }
79387   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79388   return jresult;
79389 }
79390
79391
79392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
79393   void * jresult ;
79394   unsigned int arg1 ;
79395   float arg2 ;
79396   Dali::Pixel::Format arg3 ;
79397   float arg4 ;
79398   float arg5 ;
79399   Dali::Toolkit::GaussianBlurView result;
79400
79401   arg1 = (unsigned int)jarg1;
79402   arg2 = (float)jarg2;
79403   arg3 = (Dali::Pixel::Format)jarg3;
79404   arg4 = (float)jarg4;
79405   arg5 = (float)jarg5;
79406   {
79407     try {
79408       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
79409     } catch (std::out_of_range& e) {
79410       {
79411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79412       };
79413     } catch (std::exception& e) {
79414       {
79415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79416       };
79417     } catch (...) {
79418       {
79419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79420       };
79421     }
79422   }
79423   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79424   return jresult;
79425 }
79426
79427
79428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
79429   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79430   Dali::Actor arg2 ;
79431   Dali::Actor *argp2 ;
79432
79433   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79434   argp2 = (Dali::Actor *)jarg2;
79435   if (!argp2) {
79436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79437     return ;
79438   }
79439   arg2 = *argp2;
79440   {
79441     try {
79442       (arg1)->Add(arg2);
79443     } catch (std::out_of_range& e) {
79444       {
79445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79446       };
79447     } catch (std::exception& e) {
79448       {
79449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79450       };
79451     } catch (...) {
79452       {
79453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79454       };
79455     }
79456   }
79457 }
79458
79459
79460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
79461   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79462   Dali::Actor arg2 ;
79463   Dali::Actor *argp2 ;
79464
79465   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79466   argp2 = (Dali::Actor *)jarg2;
79467   if (!argp2) {
79468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79469     return ;
79470   }
79471   arg2 = *argp2;
79472   {
79473     try {
79474       (arg1)->Remove(arg2);
79475     } catch (std::out_of_range& e) {
79476       {
79477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79478       };
79479     } catch (std::exception& e) {
79480       {
79481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79482       };
79483     } catch (...) {
79484       {
79485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79486       };
79487     }
79488   }
79489 }
79490
79491
79492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
79493   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79494
79495   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79496   {
79497     try {
79498       (arg1)->Activate();
79499     } catch (std::out_of_range& e) {
79500       {
79501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79502       };
79503     } catch (std::exception& e) {
79504       {
79505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79506       };
79507     } catch (...) {
79508       {
79509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79510       };
79511     }
79512   }
79513 }
79514
79515
79516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
79517   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79518
79519   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79520   {
79521     try {
79522       (arg1)->ActivateOnce();
79523     } catch (std::out_of_range& e) {
79524       {
79525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79526       };
79527     } catch (std::exception& e) {
79528       {
79529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79530       };
79531     } catch (...) {
79532       {
79533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79534       };
79535     }
79536   }
79537 }
79538
79539
79540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
79541   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79542
79543   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79544   {
79545     try {
79546       (arg1)->Deactivate();
79547     } catch (std::out_of_range& e) {
79548       {
79549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79550       };
79551     } catch (std::exception& e) {
79552       {
79553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79554       };
79555     } catch (...) {
79556       {
79557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79558       };
79559     }
79560   }
79561 }
79562
79563
79564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
79565   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79566   Dali::Image arg2 ;
79567   Dali::FrameBufferImage arg3 ;
79568   Dali::Image *argp2 ;
79569   Dali::FrameBufferImage *argp3 ;
79570
79571   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79572   argp2 = (Dali::Image *)jarg2;
79573   if (!argp2) {
79574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
79575     return ;
79576   }
79577   arg2 = *argp2;
79578   argp3 = (Dali::FrameBufferImage *)jarg3;
79579   if (!argp3) {
79580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
79581     return ;
79582   }
79583   arg3 = *argp3;
79584   {
79585     try {
79586       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
79587     } catch (std::out_of_range& e) {
79588       {
79589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79590       };
79591     } catch (std::exception& e) {
79592       {
79593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79594       };
79595     } catch (...) {
79596       {
79597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79598       };
79599     }
79600   }
79601 }
79602
79603
79604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
79605   int jresult ;
79606   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79607   Dali::Property::Index result;
79608
79609   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79610   {
79611     try {
79612       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
79613     } catch (std::out_of_range& e) {
79614       {
79615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79616       };
79617     } catch (std::exception& e) {
79618       {
79619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (...) {
79622       {
79623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79624       };
79625     }
79626   }
79627   jresult = result;
79628   return jresult;
79629 }
79630
79631
79632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
79633   void * jresult ;
79634   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79635   Dali::FrameBufferImage result;
79636
79637   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79638   {
79639     try {
79640       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
79641     } catch (std::out_of_range& e) {
79642       {
79643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (std::exception& e) {
79646       {
79647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79648       };
79649     } catch (...) {
79650       {
79651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79652       };
79653     }
79654   }
79655   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
79656   return jresult;
79657 }
79658
79659
79660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
79661   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79662   Dali::Vector4 *arg2 = 0 ;
79663
79664   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79665   arg2 = (Dali::Vector4 *)jarg2;
79666   if (!arg2) {
79667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
79668     return ;
79669   }
79670   {
79671     try {
79672       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
79673     } catch (std::out_of_range& e) {
79674       {
79675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79676       };
79677     } catch (std::exception& e) {
79678       {
79679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79680       };
79681     } catch (...) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79684       };
79685     }
79686   }
79687 }
79688
79689
79690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
79691   void * jresult ;
79692   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79693   Dali::Vector4 result;
79694
79695   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79696   {
79697     try {
79698       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
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 = new Dali::Vector4((const Dali::Vector4 &)result);
79714   return jresult;
79715 }
79716
79717
79718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
79719   void * jresult ;
79720   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79721   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
79722
79723   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79724   {
79725     try {
79726       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
79727     } catch (std::out_of_range& e) {
79728       {
79729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79730       };
79731     } catch (std::exception& e) {
79732       {
79733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79734       };
79735     } catch (...) {
79736       {
79737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79738       };
79739     }
79740   }
79741   jresult = (void *)result;
79742   return jresult;
79743 }
79744
79745
79746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
79747   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79748
79749   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79750   {
79751     try {
79752       delete arg1;
79753     } catch (std::out_of_range& e) {
79754       {
79755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79756       };
79757     } catch (std::exception& e) {
79758       {
79759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79760       };
79761     } catch (...) {
79762       {
79763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79764       };
79765     }
79766   }
79767 }
79768
79769
79770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
79771   unsigned int jresult ;
79772   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79773   unsigned int result;
79774
79775   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79776   {
79777     try {
79778       result = (unsigned int)(arg1)->GetNumberOfPages();
79779     } catch (std::out_of_range& e) {
79780       {
79781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79782       };
79783     } catch (std::exception& e) {
79784       {
79785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79786       };
79787     } catch (...) {
79788       {
79789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79790       };
79791     }
79792   }
79793   jresult = result;
79794   return jresult;
79795 }
79796
79797
79798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
79799   void * jresult ;
79800   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79801   unsigned int arg2 ;
79802   Dali::Texture result;
79803
79804   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79805   arg2 = (unsigned int)jarg2;
79806   {
79807     try {
79808       result = (arg1)->NewPage(arg2);
79809     } catch (std::out_of_range& e) {
79810       {
79811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79812       };
79813     } catch (std::exception& e) {
79814       {
79815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79816       };
79817     } catch (...) {
79818       {
79819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79820       };
79821     }
79822   }
79823   jresult = new Dali::Texture((const Dali::Texture &)result);
79824   return jresult;
79825 }
79826
79827
79828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
79829   int jresult ;
79830   int result;
79831
79832   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
79833   jresult = (int)result;
79834   return jresult;
79835 }
79836
79837
79838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
79839   int jresult ;
79840   int result;
79841
79842   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
79843   jresult = (int)result;
79844   return jresult;
79845 }
79846
79847
79848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
79849   int jresult ;
79850   int result;
79851
79852   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
79853   jresult = (int)result;
79854   return jresult;
79855 }
79856
79857
79858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
79859   void * jresult ;
79860   Dali::Toolkit::PageTurnView::Property *result = 0 ;
79861
79862   {
79863     try {
79864       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
79865     } catch (std::out_of_range& e) {
79866       {
79867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79868       };
79869     } catch (std::exception& e) {
79870       {
79871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79872       };
79873     } catch (...) {
79874       {
79875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79876       };
79877     }
79878   }
79879   jresult = (void *)result;
79880   return jresult;
79881 }
79882
79883
79884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
79885   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
79886
79887   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
79888   {
79889     try {
79890       delete arg1;
79891     } catch (std::out_of_range& e) {
79892       {
79893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79894       };
79895     } catch (std::exception& e) {
79896       {
79897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79898       };
79899     } catch (...) {
79900       {
79901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79902       };
79903     }
79904   }
79905 }
79906
79907
79908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
79909   void * jresult ;
79910   Dali::Toolkit::PageTurnView *result = 0 ;
79911
79912   {
79913     try {
79914       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
79915     } catch (std::out_of_range& e) {
79916       {
79917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79918       };
79919     } catch (std::exception& e) {
79920       {
79921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79922       };
79923     } catch (...) {
79924       {
79925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79926       };
79927     }
79928   }
79929   jresult = (void *)result;
79930   return jresult;
79931 }
79932
79933
79934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
79935   void * jresult ;
79936   Dali::Toolkit::PageTurnView *arg1 = 0 ;
79937   Dali::Toolkit::PageTurnView *result = 0 ;
79938
79939   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79940   if (!arg1) {
79941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
79942     return 0;
79943   }
79944   {
79945     try {
79946       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
79947     } catch (std::out_of_range& e) {
79948       {
79949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79950       };
79951     } catch (std::exception& e) {
79952       {
79953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79954       };
79955     } catch (...) {
79956       {
79957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79958       };
79959     }
79960   }
79961   jresult = (void *)result;
79962   return jresult;
79963 }
79964
79965
79966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
79967   void * jresult ;
79968   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
79969   Dali::Toolkit::PageTurnView *arg2 = 0 ;
79970   Dali::Toolkit::PageTurnView *result = 0 ;
79971
79972   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
79973   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
79974   if (!arg2) {
79975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
79976     return 0;
79977   }
79978   {
79979     try {
79980       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
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 = (void *)result;
79996   return jresult;
79997 }
79998
79999
80000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
80001   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80002
80003   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80004   {
80005     try {
80006       delete arg1;
80007     } catch (std::out_of_range& e) {
80008       {
80009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80010       };
80011     } catch (std::exception& e) {
80012       {
80013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80014       };
80015     } catch (...) {
80016       {
80017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80018       };
80019     }
80020   }
80021 }
80022
80023
80024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
80025   void * jresult ;
80026   Dali::BaseHandle arg1 ;
80027   Dali::BaseHandle *argp1 ;
80028   Dali::Toolkit::PageTurnView result;
80029
80030   argp1 = (Dali::BaseHandle *)jarg1;
80031   if (!argp1) {
80032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80033     return 0;
80034   }
80035   arg1 = *argp1;
80036   {
80037     try {
80038       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
80039     } catch (std::out_of_range& e) {
80040       {
80041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80042       };
80043     } catch (std::exception& e) {
80044       {
80045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80046       };
80047     } catch (...) {
80048       {
80049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80050       };
80051     }
80052   }
80053   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
80054   return jresult;
80055 }
80056
80057
80058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
80059   void * jresult ;
80060   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80061   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
80062
80063   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80064   {
80065     try {
80066       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
80067     } catch (std::out_of_range& e) {
80068       {
80069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80070       };
80071     } catch (std::exception& e) {
80072       {
80073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80074       };
80075     } catch (...) {
80076       {
80077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80078       };
80079     }
80080   }
80081   jresult = (void *)result;
80082   return jresult;
80083 }
80084
80085
80086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
80087   void * jresult ;
80088   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80089   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
80090
80091   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80092   {
80093     try {
80094       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
80095     } catch (std::out_of_range& e) {
80096       {
80097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80098       };
80099     } catch (std::exception& e) {
80100       {
80101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80102       };
80103     } catch (...) {
80104       {
80105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80106       };
80107     }
80108   }
80109   jresult = (void *)result;
80110   return jresult;
80111 }
80112
80113
80114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
80115   void * jresult ;
80116   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80117   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
80118
80119   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80120   {
80121     try {
80122       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
80123     } catch (std::out_of_range& e) {
80124       {
80125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80126       };
80127     } catch (std::exception& e) {
80128       {
80129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80130       };
80131     } catch (...) {
80132       {
80133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80134       };
80135     }
80136   }
80137   jresult = (void *)result;
80138   return jresult;
80139 }
80140
80141
80142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
80143   void * jresult ;
80144   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80145   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
80146
80147   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80148   {
80149     try {
80150       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
80151     } catch (std::out_of_range& e) {
80152       {
80153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80154       };
80155     } catch (std::exception& e) {
80156       {
80157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80158       };
80159     } catch (...) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80162       };
80163     }
80164   }
80165   jresult = (void *)result;
80166   return jresult;
80167 }
80168
80169
80170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
80171   void * jresult ;
80172   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80173
80174   {
80175     try {
80176       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
80177     } catch (std::out_of_range& e) {
80178       {
80179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (std::exception& e) {
80182       {
80183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80184       };
80185     } catch (...) {
80186       {
80187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80188       };
80189     }
80190   }
80191   jresult = (void *)result;
80192   return jresult;
80193 }
80194
80195
80196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
80197   void * jresult ;
80198   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
80199   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80200
80201   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80202   if (!arg1) {
80203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
80204     return 0;
80205   }
80206   {
80207     try {
80208       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80216       };
80217     } catch (...) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80220       };
80221     }
80222   }
80223   jresult = (void *)result;
80224   return jresult;
80225 }
80226
80227
80228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
80229   void * jresult ;
80230   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
80231   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
80232   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80233
80234   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80235   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
80236   if (!arg2) {
80237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
80238     return 0;
80239   }
80240   {
80241     try {
80242       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
80243     } catch (std::out_of_range& e) {
80244       {
80245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80246       };
80247     } catch (std::exception& e) {
80248       {
80249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80250       };
80251     } catch (...) {
80252       {
80253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80254       };
80255     }
80256   }
80257   jresult = (void *)result;
80258   return jresult;
80259 }
80260
80261
80262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
80263   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
80264
80265   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80266   {
80267     try {
80268       delete arg1;
80269     } catch (std::out_of_range& e) {
80270       {
80271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80272       };
80273     } catch (std::exception& e) {
80274       {
80275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80276       };
80277     } catch (...) {
80278       {
80279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80280       };
80281     }
80282   }
80283 }
80284
80285
80286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
80287   void * jresult ;
80288   Dali::Toolkit::PageFactory *arg1 = 0 ;
80289   Dali::Vector2 *arg2 = 0 ;
80290   Dali::Toolkit::PageTurnLandscapeView result;
80291
80292   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
80293   if (!arg1) {
80294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
80295     return 0;
80296   }
80297   arg2 = (Dali::Vector2 *)jarg2;
80298   if (!arg2) {
80299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80300     return 0;
80301   }
80302   {
80303     try {
80304       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
80305     } catch (std::out_of_range& e) {
80306       {
80307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80308       };
80309     } catch (std::exception& e) {
80310       {
80311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80312       };
80313     } catch (...) {
80314       {
80315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80316       };
80317     }
80318   }
80319   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
80320   return jresult;
80321 }
80322
80323
80324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
80325   void * jresult ;
80326   Dali::BaseHandle arg1 ;
80327   Dali::BaseHandle *argp1 ;
80328   Dali::Toolkit::PageTurnLandscapeView result;
80329
80330   argp1 = (Dali::BaseHandle *)jarg1;
80331   if (!argp1) {
80332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80333     return 0;
80334   }
80335   arg1 = *argp1;
80336   {
80337     try {
80338       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
80339     } catch (std::out_of_range& e) {
80340       {
80341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80342       };
80343     } catch (std::exception& e) {
80344       {
80345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80346       };
80347     } catch (...) {
80348       {
80349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80350       };
80351     }
80352   }
80353   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
80354   return jresult;
80355 }
80356
80357
80358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
80359   void * jresult ;
80360   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80361
80362   {
80363     try {
80364       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
80365     } catch (std::out_of_range& e) {
80366       {
80367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80368       };
80369     } catch (std::exception& e) {
80370       {
80371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80372       };
80373     } catch (...) {
80374       {
80375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80376       };
80377     }
80378   }
80379   jresult = (void *)result;
80380   return jresult;
80381 }
80382
80383
80384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
80385   void * jresult ;
80386   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
80387   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80388
80389   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80390   if (!arg1) {
80391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
80392     return 0;
80393   }
80394   {
80395     try {
80396       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
80397     } catch (std::out_of_range& e) {
80398       {
80399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80400       };
80401     } catch (std::exception& e) {
80402       {
80403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80404       };
80405     } catch (...) {
80406       {
80407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80408       };
80409     }
80410   }
80411   jresult = (void *)result;
80412   return jresult;
80413 }
80414
80415
80416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
80417   void * jresult ;
80418   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80419   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
80420   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80421
80422   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80423   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
80424   if (!arg2) {
80425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
80426     return 0;
80427   }
80428   {
80429     try {
80430       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
80431     } catch (std::out_of_range& e) {
80432       {
80433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80434       };
80435     } catch (std::exception& e) {
80436       {
80437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80438       };
80439     } catch (...) {
80440       {
80441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80442       };
80443     }
80444   }
80445   jresult = (void *)result;
80446   return jresult;
80447 }
80448
80449
80450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
80451   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80452
80453   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80454   {
80455     try {
80456       delete arg1;
80457     } catch (std::out_of_range& e) {
80458       {
80459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80460       };
80461     } catch (std::exception& e) {
80462       {
80463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80464       };
80465     } catch (...) {
80466       {
80467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80468       };
80469     }
80470   }
80471 }
80472
80473
80474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
80475   void * jresult ;
80476   Dali::Toolkit::PageFactory *arg1 = 0 ;
80477   Dali::Vector2 *arg2 = 0 ;
80478   Dali::Toolkit::PageTurnPortraitView result;
80479
80480   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
80481   if (!arg1) {
80482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
80483     return 0;
80484   }
80485   arg2 = (Dali::Vector2 *)jarg2;
80486   if (!arg2) {
80487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80488     return 0;
80489   }
80490   {
80491     try {
80492       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
80493     } catch (std::out_of_range& e) {
80494       {
80495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80496       };
80497     } catch (std::exception& e) {
80498       {
80499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80500       };
80501     } catch (...) {
80502       {
80503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80504       };
80505     }
80506   }
80507   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80508   return jresult;
80509 }
80510
80511
80512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
80513   void * jresult ;
80514   Dali::BaseHandle arg1 ;
80515   Dali::BaseHandle *argp1 ;
80516   Dali::Toolkit::PageTurnPortraitView result;
80517
80518   argp1 = (Dali::BaseHandle *)jarg1;
80519   if (!argp1) {
80520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80521     return 0;
80522   }
80523   arg1 = *argp1;
80524   {
80525     try {
80526       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
80527     } catch (std::out_of_range& e) {
80528       {
80529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80530       };
80531     } catch (std::exception& e) {
80532       {
80533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80534       };
80535     } catch (...) {
80536       {
80537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80538       };
80539     }
80540   }
80541   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80542   return jresult;
80543 }
80544
80545
80546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
80547   int jresult ;
80548   int result;
80549
80550   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
80551   jresult = (int)result;
80552   return jresult;
80553 }
80554
80555
80556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
80557   int jresult ;
80558   int result;
80559
80560   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
80561   jresult = (int)result;
80562   return jresult;
80563 }
80564
80565
80566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
80567   int jresult ;
80568   int result;
80569
80570   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
80571   jresult = (int)result;
80572   return jresult;
80573 }
80574
80575
80576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
80577   void * jresult ;
80578   Dali::Toolkit::ToggleButton::Property *result = 0 ;
80579
80580   {
80581     try {
80582       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
80583     } catch (std::out_of_range& e) {
80584       {
80585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80586       };
80587     } catch (std::exception& e) {
80588       {
80589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80590       };
80591     } catch (...) {
80592       {
80593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80594       };
80595     }
80596   }
80597   jresult = (void *)result;
80598   return jresult;
80599 }
80600
80601
80602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
80603   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
80604
80605   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
80606   {
80607     try {
80608       delete arg1;
80609     } catch (std::out_of_range& e) {
80610       {
80611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80612       };
80613     } catch (std::exception& e) {
80614       {
80615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80616       };
80617     } catch (...) {
80618       {
80619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80620       };
80621     }
80622   }
80623 }
80624
80625
80626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
80627   void * jresult ;
80628   Dali::Toolkit::ToggleButton *result = 0 ;
80629
80630   {
80631     try {
80632       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
80633     } catch (std::out_of_range& e) {
80634       {
80635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80636       };
80637     } catch (std::exception& e) {
80638       {
80639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80640       };
80641     } catch (...) {
80642       {
80643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80644       };
80645     }
80646   }
80647   jresult = (void *)result;
80648   return jresult;
80649 }
80650
80651
80652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
80653   void * jresult ;
80654   Dali::Toolkit::ToggleButton *arg1 = 0 ;
80655   Dali::Toolkit::ToggleButton *result = 0 ;
80656
80657   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80658   if (!arg1) {
80659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
80660     return 0;
80661   }
80662   {
80663     try {
80664       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
80665     } catch (std::out_of_range& e) {
80666       {
80667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80668       };
80669     } catch (std::exception& e) {
80670       {
80671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80672       };
80673     } catch (...) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80676       };
80677     }
80678   }
80679   jresult = (void *)result;
80680   return jresult;
80681 }
80682
80683
80684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
80685   void * jresult ;
80686   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
80687   Dali::Toolkit::ToggleButton *arg2 = 0 ;
80688   Dali::Toolkit::ToggleButton *result = 0 ;
80689
80690   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80691   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
80692   if (!arg2) {
80693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
80694     return 0;
80695   }
80696   {
80697     try {
80698       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
80699     } catch (std::out_of_range& e) {
80700       {
80701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80702       };
80703     } catch (std::exception& e) {
80704       {
80705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80706       };
80707     } catch (...) {
80708       {
80709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80710       };
80711     }
80712   }
80713   jresult = (void *)result;
80714   return jresult;
80715 }
80716
80717
80718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
80719   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
80720
80721   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80722   {
80723     try {
80724       delete arg1;
80725     } catch (std::out_of_range& e) {
80726       {
80727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80728       };
80729     } catch (std::exception& e) {
80730       {
80731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80732       };
80733     } catch (...) {
80734       {
80735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80736       };
80737     }
80738   }
80739 }
80740
80741
80742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
80743   void * jresult ;
80744   Dali::Toolkit::ToggleButton result;
80745
80746   {
80747     try {
80748       result = Dali::Toolkit::ToggleButton::New();
80749     } catch (std::out_of_range& e) {
80750       {
80751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80752       };
80753     } catch (std::exception& e) {
80754       {
80755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80756       };
80757     } catch (...) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80760       };
80761     }
80762   }
80763   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
80764   return jresult;
80765 }
80766
80767
80768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
80769   void * jresult ;
80770   Dali::BaseHandle arg1 ;
80771   Dali::BaseHandle *argp1 ;
80772   Dali::Toolkit::ToggleButton result;
80773
80774   argp1 = (Dali::BaseHandle *)jarg1;
80775   if (!argp1) {
80776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80777     return 0;
80778   }
80779   arg1 = *argp1;
80780   {
80781     try {
80782       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
80783     } catch (std::out_of_range& e) {
80784       {
80785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80786       };
80787     } catch (std::exception& e) {
80788       {
80789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80790       };
80791     } catch (...) {
80792       {
80793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80794       };
80795     }
80796   }
80797   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
80798   return jresult;
80799 }
80800
80801
80802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
80803   void * jresult ;
80804   Dali::Toolkit::Visual::Base *result = 0 ;
80805
80806   {
80807     try {
80808       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
80809     } catch (std::out_of_range& e) {
80810       {
80811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80812       };
80813     } catch (std::exception& e) {
80814       {
80815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80816       };
80817     } catch (...) {
80818       {
80819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80820       };
80821     }
80822   }
80823   jresult = (void *)result;
80824   return jresult;
80825 }
80826
80827
80828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
80829   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80830
80831   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80832   {
80833     try {
80834       delete arg1;
80835     } catch (std::out_of_range& e) {
80836       {
80837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80838       };
80839     } catch (std::exception& e) {
80840       {
80841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80842       };
80843     } catch (...) {
80844       {
80845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80846       };
80847     }
80848   }
80849 }
80850
80851
80852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
80853   void * jresult ;
80854   Dali::Toolkit::Visual::Base *arg1 = 0 ;
80855   Dali::Toolkit::Visual::Base *result = 0 ;
80856
80857   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80858   if (!arg1) {
80859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
80860     return 0;
80861   }
80862   {
80863     try {
80864       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
80865     } catch (std::out_of_range& e) {
80866       {
80867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80868       };
80869     } catch (std::exception& e) {
80870       {
80871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80872       };
80873     } catch (...) {
80874       {
80875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80876       };
80877     }
80878   }
80879   jresult = (void *)result;
80880   return jresult;
80881 }
80882
80883
80884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
80885   void * jresult ;
80886   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80887   Dali::Toolkit::Visual::Base *arg2 = 0 ;
80888   Dali::Toolkit::Visual::Base *result = 0 ;
80889
80890   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80891   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
80892   if (!arg2) {
80893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
80894     return 0;
80895   }
80896   {
80897     try {
80898       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
80899     } catch (std::out_of_range& e) {
80900       {
80901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80902       };
80903     } catch (std::exception& e) {
80904       {
80905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80906       };
80907     } catch (...) {
80908       {
80909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80910       };
80911     }
80912   }
80913   jresult = (void *)result;
80914   return jresult;
80915 }
80916
80917
80918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
80919   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80920   std::string *arg2 = 0 ;
80921
80922   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80923   if (!jarg2) {
80924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80925     return ;
80926   }
80927   std::string arg2_str(jarg2);
80928   arg2 = &arg2_str;
80929   {
80930     try {
80931       (arg1)->SetName((std::string const &)*arg2);
80932     } catch (std::out_of_range& e) {
80933       {
80934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80935       };
80936     } catch (std::exception& e) {
80937       {
80938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80939       };
80940     } catch (...) {
80941       {
80942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80943       };
80944     }
80945   }
80946
80947   //argout typemap for const std::string&
80948
80949 }
80950
80951
80952 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
80953   char * jresult ;
80954   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80955   std::string *result = 0 ;
80956
80957   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80958   {
80959     try {
80960       result = (std::string *) &(arg1)->GetName();
80961     } catch (std::out_of_range& e) {
80962       {
80963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80964       };
80965     } catch (std::exception& e) {
80966       {
80967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80968       };
80969     } catch (...) {
80970       {
80971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80972       };
80973     }
80974   }
80975   jresult = SWIG_csharp_string_callback(result->c_str());
80976   return jresult;
80977 }
80978
80979
80980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
80981   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80982   Dali::Property::Map *arg2 = 0 ;
80983   Dali::Size arg3 ;
80984   Dali::Size *argp3 ;
80985
80986   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80987   arg2 = (Dali::Property::Map *)jarg2;
80988   if (!arg2) {
80989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
80990     return ;
80991   }
80992   argp3 = (Dali::Size *)jarg3;
80993   if (!argp3) {
80994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
80995     return ;
80996   }
80997   arg3 = *argp3;
80998   {
80999     try {
81000       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
81001     } catch (std::out_of_range& e) {
81002       {
81003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81004       };
81005     } catch (std::exception& e) {
81006       {
81007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81008       };
81009     } catch (...) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81012       };
81013     }
81014   }
81015 }
81016
81017
81018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
81019   float jresult ;
81020   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81021   float arg2 ;
81022   float result;
81023
81024   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81025   arg2 = (float)jarg2;
81026   {
81027     try {
81028       result = (float)(arg1)->GetHeightForWidth(arg2);
81029     } catch (std::out_of_range& e) {
81030       {
81031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81032       };
81033     } catch (std::exception& e) {
81034       {
81035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81036       };
81037     } catch (...) {
81038       {
81039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81040       };
81041     }
81042   }
81043   jresult = result;
81044   return jresult;
81045 }
81046
81047
81048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
81049   float jresult ;
81050   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81051   float arg2 ;
81052   float result;
81053
81054   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81055   arg2 = (float)jarg2;
81056   {
81057     try {
81058       result = (float)(arg1)->GetWidthForHeight(arg2);
81059     } catch (std::out_of_range& e) {
81060       {
81061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81062       };
81063     } catch (std::exception& e) {
81064       {
81065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81066       };
81067     } catch (...) {
81068       {
81069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81070       };
81071     }
81072   }
81073   jresult = result;
81074   return jresult;
81075 }
81076
81077
81078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
81079   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81080   Dali::Vector2 *arg2 = 0 ;
81081
81082   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81083   arg2 = (Dali::Vector2 *)jarg2;
81084   if (!arg2) {
81085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
81086     return ;
81087   }
81088   {
81089     try {
81090       (arg1)->GetNaturalSize(*arg2);
81091     } catch (std::out_of_range& e) {
81092       {
81093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81094       };
81095     } catch (std::exception& e) {
81096       {
81097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81098       };
81099     } catch (...) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81102       };
81103     }
81104   }
81105 }
81106
81107
81108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
81109   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81110   float arg2 ;
81111
81112   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81113   arg2 = (int)jarg2;
81114   {
81115     try {
81116       (arg1)->SetDepthIndex(arg2);
81117     } catch (std::out_of_range& e) {
81118       {
81119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81120       };
81121     } catch (std::exception& e) {
81122       {
81123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81124       };
81125     } catch (...) {
81126       {
81127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81128       };
81129     }
81130   }
81131 }
81132
81133
81134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
81135   int jresult ;
81136   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81137   int result;
81138
81139   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81140   {
81141     try {
81142       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
81143     } catch (std::out_of_range& e) {
81144       {
81145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81146       };
81147     } catch (std::exception& e) {
81148       {
81149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81150       };
81151     } catch (...) {
81152       {
81153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81154       };
81155     }
81156   }
81157   jresult = result;
81158   return jresult;
81159 }
81160
81161
81162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
81163   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81164   Dali::Property::Map *arg2 = 0 ;
81165
81166   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81167   arg2 = (Dali::Property::Map *)jarg2;
81168   if (!arg2) {
81169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
81170     return ;
81171   }
81172   {
81173     try {
81174       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
81175     } catch (std::out_of_range& e) {
81176       {
81177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81178       };
81179     } catch (std::exception& e) {
81180       {
81181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81182       };
81183     } catch (...) {
81184       {
81185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81186       };
81187     }
81188   }
81189 }
81190
81191
81192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
81193   void * jresult ;
81194   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
81195   Dali::Toolkit::Visual::Base *result = 0 ;
81196
81197   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
81198   {
81199     try {
81200       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
81201     } catch (std::out_of_range& e) {
81202       {
81203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81204       };
81205     } catch (std::exception& e) {
81206       {
81207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81208       };
81209     } catch (...) {
81210       {
81211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81212       };
81213     }
81214   }
81215   jresult = (void *)result;
81216   return jresult;
81217 }
81218
81219
81220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
81221   void * jresult ;
81222   Dali::Toolkit::VisualFactory result;
81223
81224   {
81225     try {
81226       result = Dali::Toolkit::VisualFactory::Get();
81227     } catch (std::out_of_range& e) {
81228       {
81229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81230       };
81231     } catch (std::exception& e) {
81232       {
81233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81234       };
81235     } catch (...) {
81236       {
81237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81238       };
81239     }
81240   }
81241   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
81242   return jresult;
81243 }
81244
81245
81246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
81247   void * jresult ;
81248   Dali::Toolkit::VisualFactory *result = 0 ;
81249
81250   {
81251     try {
81252       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
81253     } catch (std::out_of_range& e) {
81254       {
81255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (std::exception& e) {
81258       {
81259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81260       };
81261     } catch (...) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81264       };
81265     }
81266   }
81267   jresult = (void *)result;
81268   return jresult;
81269 }
81270
81271
81272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
81273   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81274
81275   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81276   {
81277     try {
81278       delete arg1;
81279     } catch (std::out_of_range& e) {
81280       {
81281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81282       };
81283     } catch (std::exception& e) {
81284       {
81285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81286       };
81287     } catch (...) {
81288       {
81289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81290       };
81291     }
81292   }
81293 }
81294
81295
81296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
81297   void * jresult ;
81298   Dali::Toolkit::VisualFactory *arg1 = 0 ;
81299   Dali::Toolkit::VisualFactory *result = 0 ;
81300
81301   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81302   if (!arg1) {
81303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
81304     return 0;
81305   }
81306   {
81307     try {
81308       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
81309     } catch (std::out_of_range& e) {
81310       {
81311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81312       };
81313     } catch (std::exception& e) {
81314       {
81315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81320       };
81321     }
81322   }
81323   jresult = (void *)result;
81324   return jresult;
81325 }
81326
81327
81328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
81329   void * jresult ;
81330   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81331   Dali::Toolkit::VisualFactory *arg2 = 0 ;
81332   Dali::Toolkit::VisualFactory *result = 0 ;
81333
81334   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81335   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
81336   if (!arg2) {
81337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
81338     return 0;
81339   }
81340   {
81341     try {
81342       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
81343     } catch (std::out_of_range& e) {
81344       {
81345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81346       };
81347     } catch (std::exception& e) {
81348       {
81349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81350       };
81351     } catch (...) {
81352       {
81353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81354       };
81355     }
81356   }
81357   jresult = (void *)result;
81358   return jresult;
81359 }
81360
81361
81362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
81363   void * jresult ;
81364   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81365   Dali::Property::Map *arg2 = 0 ;
81366   Dali::Toolkit::Visual::Base result;
81367
81368   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81369   arg2 = (Dali::Property::Map *)jarg2;
81370   if (!arg2) {
81371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
81372     return 0;
81373   }
81374   {
81375     try {
81376       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
81377     } catch (std::out_of_range& e) {
81378       {
81379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (std::exception& e) {
81382       {
81383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81392   return jresult;
81393 }
81394
81395
81396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
81397   void * jresult ;
81398   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81399   Dali::Image *arg2 = 0 ;
81400   Dali::Toolkit::Visual::Base result;
81401
81402   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81403   arg2 = (Dali::Image *)jarg2;
81404   if (!arg2) {
81405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
81406     return 0;
81407   }
81408   {
81409     try {
81410       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
81411     } catch (std::out_of_range& e) {
81412       {
81413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81414       };
81415     } catch (std::exception& e) {
81416       {
81417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81418       };
81419     } catch (...) {
81420       {
81421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81422       };
81423     }
81424   }
81425   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81426   return jresult;
81427 }
81428
81429
81430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
81431   void * jresult ;
81432   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81433   std::string *arg2 = 0 ;
81434   Dali::ImageDimensions arg3 ;
81435   Dali::ImageDimensions *argp3 ;
81436   Dali::Toolkit::Visual::Base result;
81437
81438   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81439   if (!jarg2) {
81440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81441     return 0;
81442   }
81443   std::string arg2_str(jarg2);
81444   arg2 = &arg2_str;
81445   argp3 = (Dali::ImageDimensions *)jarg3;
81446   if (!argp3) {
81447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81448     return 0;
81449   }
81450   arg3 = *argp3;
81451   {
81452     try {
81453       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
81454     } catch (std::out_of_range& e) {
81455       {
81456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81457       };
81458     } catch (std::exception& e) {
81459       {
81460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81461       };
81462     } catch (...) {
81463       {
81464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81465       };
81466     }
81467   }
81468   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81469
81470   //argout typemap for const std::string&
81471
81472   return jresult;
81473 }
81474
81475
81476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
81477   void * jresult ;
81478   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81479
81480   {
81481     try {
81482       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
81483     } catch (std::out_of_range& e) {
81484       {
81485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81486       };
81487     } catch (std::exception& e) {
81488       {
81489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81490       };
81491     } catch (...) {
81492       {
81493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81494       };
81495     }
81496   }
81497   jresult = (void *)result;
81498   return jresult;
81499 }
81500
81501
81502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
81503   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81504
81505   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81506   {
81507     try {
81508       delete arg1;
81509     } catch (std::out_of_range& e) {
81510       {
81511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81512       };
81513     } catch (std::exception& e) {
81514       {
81515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81516       };
81517     } catch (...) {
81518       {
81519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81520       };
81521     }
81522   }
81523 }
81524
81525
81526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
81527   void * jresult ;
81528   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
81529   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81530
81531   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81532   if (!arg1) {
81533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
81534     return 0;
81535   }
81536   {
81537     try {
81538       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
81539     } catch (std::out_of_range& e) {
81540       {
81541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81542       };
81543     } catch (std::exception& e) {
81544       {
81545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81546       };
81547     } catch (...) {
81548       {
81549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81550       };
81551     }
81552   }
81553   jresult = (void *)result;
81554   return jresult;
81555 }
81556
81557
81558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
81559   void * jresult ;
81560   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81561   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
81562   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81563
81564   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81565   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
81566   if (!arg2) {
81567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
81568     return 0;
81569   }
81570   {
81571     try {
81572       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
81573     } catch (std::out_of_range& e) {
81574       {
81575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81576       };
81577     } catch (std::exception& e) {
81578       {
81579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81580       };
81581     } catch (...) {
81582       {
81583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81584       };
81585     }
81586   }
81587   jresult = (void *)result;
81588   return jresult;
81589 }
81590
81591
81592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
81593   void * jresult ;
81594   Dali::Toolkit::AsyncImageLoader result;
81595
81596   {
81597     try {
81598       result = Dali::Toolkit::AsyncImageLoader::New();
81599     } catch (std::out_of_range& e) {
81600       {
81601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81602       };
81603     } catch (std::exception& e) {
81604       {
81605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81606       };
81607     } catch (...) {
81608       {
81609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81610       };
81611     }
81612   }
81613   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
81614   return jresult;
81615 }
81616
81617
81618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
81619   void * jresult ;
81620   Dali::BaseHandle arg1 ;
81621   Dali::BaseHandle *argp1 ;
81622   Dali::Toolkit::AsyncImageLoader result;
81623
81624   argp1 = (Dali::BaseHandle *)jarg1;
81625   if (!argp1) {
81626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81627     return 0;
81628   }
81629   arg1 = *argp1;
81630   {
81631     try {
81632       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
81633     } catch (std::out_of_range& e) {
81634       {
81635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81636       };
81637     } catch (std::exception& e) {
81638       {
81639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81640       };
81641     } catch (...) {
81642       {
81643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81644       };
81645     }
81646   }
81647   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
81648   return jresult;
81649 }
81650
81651
81652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
81653   unsigned int jresult ;
81654   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81655   std::string *arg2 = 0 ;
81656   uint32_t result;
81657
81658   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81659   if (!jarg2) {
81660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81661     return 0;
81662   }
81663   std::string arg2_str(jarg2);
81664   arg2 = &arg2_str;
81665   {
81666     try {
81667       result = (arg1)->Load((std::string const &)*arg2);
81668     } catch (std::out_of_range& e) {
81669       {
81670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81671       };
81672     } catch (std::exception& e) {
81673       {
81674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81675       };
81676     } catch (...) {
81677       {
81678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81679       };
81680     }
81681   }
81682   jresult = result;
81683
81684   //argout typemap for const std::string&
81685
81686   return jresult;
81687 }
81688
81689
81690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
81691   unsigned int jresult ;
81692   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81693   std::string *arg2 = 0 ;
81694   Dali::ImageDimensions arg3 ;
81695   Dali::ImageDimensions *argp3 ;
81696   uint32_t result;
81697
81698   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81699   if (!jarg2) {
81700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81701     return 0;
81702   }
81703   std::string arg2_str(jarg2);
81704   arg2 = &arg2_str;
81705   argp3 = (Dali::ImageDimensions *)jarg3;
81706   if (!argp3) {
81707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81708     return 0;
81709   }
81710   arg3 = *argp3;
81711   {
81712     try {
81713       result = (arg1)->Load((std::string const &)*arg2,arg3);
81714     } catch (std::out_of_range& e) {
81715       {
81716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81717       };
81718     } catch (std::exception& e) {
81719       {
81720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81721       };
81722     } catch (...) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81725       };
81726     }
81727   }
81728   jresult = result;
81729
81730   //argout typemap for const std::string&
81731
81732   return jresult;
81733 }
81734
81735
81736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
81737   unsigned int jresult ;
81738   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81739   std::string *arg2 = 0 ;
81740   Dali::ImageDimensions arg3 ;
81741   Dali::FittingMode::Type arg4 ;
81742   Dali::SamplingMode::Type arg5 ;
81743   bool arg6 ;
81744   Dali::ImageDimensions *argp3 ;
81745   uint32_t result;
81746
81747   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81748   if (!jarg2) {
81749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81750     return 0;
81751   }
81752   std::string arg2_str(jarg2);
81753   arg2 = &arg2_str;
81754   argp3 = (Dali::ImageDimensions *)jarg3;
81755   if (!argp3) {
81756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81757     return 0;
81758   }
81759   arg3 = *argp3;
81760   arg4 = (Dali::FittingMode::Type)jarg4;
81761   arg5 = (Dali::SamplingMode::Type)jarg5;
81762   arg6 = jarg6 ? true : false;
81763   {
81764     try {
81765       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
81766     } catch (std::out_of_range& e) {
81767       {
81768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81769       };
81770     } catch (std::exception& e) {
81771       {
81772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81773       };
81774     } catch (...) {
81775       {
81776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81777       };
81778     }
81779   }
81780   jresult = result;
81781
81782   //argout typemap for const std::string&
81783
81784   return jresult;
81785 }
81786
81787
81788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
81789   unsigned int jresult ;
81790   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81791   uint32_t arg2 ;
81792   bool result;
81793
81794   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81795   arg2 = (uint32_t)jarg2;
81796   {
81797     try {
81798       result = (bool)(arg1)->Cancel(arg2);
81799     } catch (std::out_of_range& e) {
81800       {
81801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81802       };
81803     } catch (std::exception& e) {
81804       {
81805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81806       };
81807     } catch (...) {
81808       {
81809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81810       };
81811     }
81812   }
81813   jresult = result;
81814   return jresult;
81815 }
81816
81817
81818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
81819   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81820
81821   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81822   {
81823     try {
81824       (arg1)->CancelAll();
81825     } catch (std::out_of_range& e) {
81826       {
81827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81828       };
81829     } catch (std::exception& e) {
81830       {
81831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81832       };
81833     } catch (...) {
81834       {
81835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81836       };
81837     }
81838   }
81839 }
81840
81841
81842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
81843   void * jresult ;
81844   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81845   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
81846
81847   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81848   {
81849     try {
81850       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
81851     } catch (std::out_of_range& e) {
81852       {
81853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81854       };
81855     } catch (std::exception& e) {
81856       {
81857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81858       };
81859     } catch (...) {
81860       {
81861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81862       };
81863     }
81864   }
81865   jresult = (void *)result;
81866   return jresult;
81867 }
81868
81869
81870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
81871   void * jresult ;
81872   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
81873   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81874
81875   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
81876   {
81877     try {
81878       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
81879     } catch (std::out_of_range& e) {
81880       {
81881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81882       };
81883     } catch (std::exception& e) {
81884       {
81885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81886       };
81887     } catch (...) {
81888       {
81889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81890       };
81891     }
81892   }
81893   jresult = (void *)result;
81894   return jresult;
81895 }
81896
81897
81898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
81899   void * jresult ;
81900   std::string *arg1 = 0 ;
81901   Dali::PixelData result;
81902
81903   if (!jarg1) {
81904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81905     return 0;
81906   }
81907   std::string arg1_str(jarg1);
81908   arg1 = &arg1_str;
81909   {
81910     try {
81911       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
81912     } catch (std::out_of_range& e) {
81913       {
81914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81915       };
81916     } catch (std::exception& e) {
81917       {
81918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81919       };
81920     } catch (...) {
81921       {
81922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81923       };
81924     }
81925   }
81926   jresult = new Dali::PixelData((const Dali::PixelData &)result);
81927
81928   //argout typemap for const std::string&
81929
81930   return jresult;
81931 }
81932
81933
81934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
81935   void * jresult ;
81936   std::string *arg1 = 0 ;
81937   Dali::ImageDimensions arg2 ;
81938   Dali::ImageDimensions *argp2 ;
81939   Dali::PixelData result;
81940
81941   if (!jarg1) {
81942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81943     return 0;
81944   }
81945   std::string arg1_str(jarg1);
81946   arg1 = &arg1_str;
81947   argp2 = (Dali::ImageDimensions *)jarg2;
81948   if (!argp2) {
81949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81950     return 0;
81951   }
81952   arg2 = *argp2;
81953   {
81954     try {
81955       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
81956     } catch (std::out_of_range& e) {
81957       {
81958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81959       };
81960     } catch (std::exception& e) {
81961       {
81962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81963       };
81964     } catch (...) {
81965       {
81966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81967       };
81968     }
81969   }
81970   jresult = new Dali::PixelData((const Dali::PixelData &)result);
81971
81972   //argout typemap for const std::string&
81973
81974   return jresult;
81975 }
81976
81977
81978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
81979   void * jresult ;
81980   std::string *arg1 = 0 ;
81981   Dali::ImageDimensions arg2 ;
81982   Dali::FittingMode::Type arg3 ;
81983   Dali::SamplingMode::Type arg4 ;
81984   bool arg5 ;
81985   Dali::ImageDimensions *argp2 ;
81986   Dali::PixelData result;
81987
81988   if (!jarg1) {
81989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81990     return 0;
81991   }
81992   std::string arg1_str(jarg1);
81993   arg1 = &arg1_str;
81994   argp2 = (Dali::ImageDimensions *)jarg2;
81995   if (!argp2) {
81996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81997     return 0;
81998   }
81999   arg2 = *argp2;
82000   arg3 = (Dali::FittingMode::Type)jarg3;
82001   arg4 = (Dali::SamplingMode::Type)jarg4;
82002   arg5 = jarg5 ? true : false;
82003   {
82004     try {
82005       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
82006     } catch (std::out_of_range& e) {
82007       {
82008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82009       };
82010     } catch (std::exception& e) {
82011       {
82012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82013       };
82014     } catch (...) {
82015       {
82016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82017       };
82018     }
82019   }
82020   jresult = new Dali::PixelData((const Dali::PixelData &)result);
82021
82022   //argout typemap for const std::string&
82023
82024   return jresult;
82025 }
82026
82027
82028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
82029   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
82030
82031   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
82032   {
82033     try {
82034       delete arg1;
82035     } catch (std::out_of_range& e) {
82036       {
82037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82038       };
82039     } catch (std::exception& e) {
82040       {
82041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82042       };
82043     } catch (...) {
82044       {
82045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82046       };
82047     }
82048   }
82049 }
82050
82051
82052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
82053   void * jresult ;
82054   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
82055   Dali::Actor arg2 ;
82056   Dali::Actor arg3 ;
82057   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
82058   Dali::Actor *argp2 ;
82059   Dali::Actor *argp3 ;
82060   Dali::Actor result;
82061
82062   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
82063   argp2 = (Dali::Actor *)jarg2;
82064   if (!argp2) {
82065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82066     return 0;
82067   }
82068   arg2 = *argp2;
82069   argp3 = (Dali::Actor *)jarg3;
82070   if (!argp3) {
82071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82072     return 0;
82073   }
82074   arg3 = *argp3;
82075   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
82076   {
82077     try {
82078       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
82079     } catch (std::out_of_range& e) {
82080       {
82081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82082       };
82083     } catch (std::exception& e) {
82084       {
82085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82086       };
82087     } catch (...) {
82088       {
82089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82090       };
82091     }
82092   }
82093   jresult = new Dali::Actor((const Dali::Actor &)result);
82094   return jresult;
82095 }
82096
82097
82098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
82099   void * jresult ;
82100   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
82101
82102   {
82103     try {
82104       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
82105     } catch (std::out_of_range& e) {
82106       {
82107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82108       };
82109     } catch (std::exception& e) {
82110       {
82111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82112       };
82113     } catch (...) {
82114       {
82115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82116       };
82117     }
82118   }
82119   jresult = (void *)result;
82120   return jresult;
82121 }
82122
82123
82124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
82125   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
82126   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
82127   if (director) {
82128     director->swig_connect_director(callback0);
82129   }
82130 }
82131
82132
82133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
82134   KeyboardFocusManager arg1 ;
82135   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
82136   KeyboardFocusManager *argp1 ;
82137
82138   argp1 = (KeyboardFocusManager *)jarg1;
82139   if (!argp1) {
82140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
82141     return ;
82142   }
82143   arg1 = *argp1;
82144   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
82145   if (!arg2) {
82146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
82147     return ;
82148   }
82149   {
82150     try {
82151       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
82152     } catch (std::out_of_range& e) {
82153       {
82154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82155       };
82156     } catch (std::exception& e) {
82157       {
82158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82159       };
82160     } catch (...) {
82161       {
82162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82163       };
82164     }
82165   }
82166 }
82167
82168
82169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
82170   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82171
82172   arg1 = (std::vector< unsigned int > *)jarg1;
82173   {
82174     try {
82175       (arg1)->clear();
82176     } catch (std::out_of_range& e) {
82177       {
82178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82179       };
82180     } catch (std::exception& e) {
82181       {
82182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82183       };
82184     } catch (...) {
82185       {
82186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82187       };
82188     }
82189   }
82190 }
82191
82192
82193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
82194   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82195   unsigned int *arg2 = 0 ;
82196   unsigned int temp2 ;
82197
82198   arg1 = (std::vector< unsigned int > *)jarg1;
82199   temp2 = (unsigned int)jarg2;
82200   arg2 = &temp2;
82201   {
82202     try {
82203       (arg1)->push_back((unsigned int const &)*arg2);
82204     } catch (std::out_of_range& e) {
82205       {
82206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82207       };
82208     } catch (std::exception& e) {
82209       {
82210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82211       };
82212     } catch (...) {
82213       {
82214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82215       };
82216     }
82217   }
82218 }
82219
82220
82221 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
82222   unsigned long jresult ;
82223   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82224   std::vector< unsigned int >::size_type result;
82225
82226   arg1 = (std::vector< unsigned int > *)jarg1;
82227   {
82228     try {
82229       result = ((std::vector< unsigned int > const *)arg1)->size();
82230     } catch (std::out_of_range& e) {
82231       {
82232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82233       };
82234     } catch (std::exception& e) {
82235       {
82236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82237       };
82238     } catch (...) {
82239       {
82240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82241       };
82242     }
82243   }
82244   jresult = (unsigned long)result;
82245   return jresult;
82246 }
82247
82248
82249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
82250   unsigned long jresult ;
82251   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82252   std::vector< unsigned int >::size_type result;
82253
82254   arg1 = (std::vector< unsigned int > *)jarg1;
82255   {
82256     try {
82257       result = ((std::vector< unsigned int > const *)arg1)->capacity();
82258     } catch (std::out_of_range& e) {
82259       {
82260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82261       };
82262     } catch (std::exception& e) {
82263       {
82264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82265       };
82266     } catch (...) {
82267       {
82268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82269       };
82270     }
82271   }
82272   jresult = (unsigned long)result;
82273   return jresult;
82274 }
82275
82276
82277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
82278   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82279   std::vector< unsigned int >::size_type arg2 ;
82280
82281   arg1 = (std::vector< unsigned int > *)jarg1;
82282   arg2 = (std::vector< unsigned int >::size_type)jarg2;
82283   {
82284     try {
82285       (arg1)->reserve(arg2);
82286     } catch (std::out_of_range& e) {
82287       {
82288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82289       };
82290     } catch (std::exception& e) {
82291       {
82292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82293       };
82294     } catch (...) {
82295       {
82296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82297       };
82298     }
82299   }
82300 }
82301
82302
82303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
82304   void * jresult ;
82305   std::vector< unsigned int > *result = 0 ;
82306
82307   {
82308     try {
82309       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
82310     } catch (std::out_of_range& e) {
82311       {
82312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82313       };
82314     } catch (std::exception& e) {
82315       {
82316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82317       };
82318     } catch (...) {
82319       {
82320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82321       };
82322     }
82323   }
82324   jresult = (void *)result;
82325   return jresult;
82326 }
82327
82328
82329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
82330   void * jresult ;
82331   std::vector< unsigned int > *arg1 = 0 ;
82332   std::vector< unsigned int > *result = 0 ;
82333
82334   arg1 = (std::vector< unsigned int > *)jarg1;
82335   if (!arg1) {
82336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82337     return 0;
82338   }
82339   {
82340     try {
82341       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
82342     } catch (std::out_of_range& e) {
82343       {
82344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82345       };
82346     } catch (std::exception& e) {
82347       {
82348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82349       };
82350     } catch (...) {
82351       {
82352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82353       };
82354     }
82355   }
82356   jresult = (void *)result;
82357   return jresult;
82358 }
82359
82360
82361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
82362   void * jresult ;
82363   int arg1 ;
82364   std::vector< unsigned int > *result = 0 ;
82365
82366   arg1 = (int)jarg1;
82367   {
82368     try {
82369       try {
82370         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
82371       }
82372       catch(std::out_of_range &_e) {
82373         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82374         return 0;
82375       }
82376
82377     } catch (std::out_of_range& e) {
82378       {
82379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82380       };
82381     } catch (std::exception& e) {
82382       {
82383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82384       };
82385     } catch (...) {
82386       {
82387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82388       };
82389     }
82390   }
82391   jresult = (void *)result;
82392   return jresult;
82393 }
82394
82395
82396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
82397   unsigned int jresult ;
82398   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82399   int arg2 ;
82400   unsigned int result;
82401
82402   arg1 = (std::vector< unsigned int > *)jarg1;
82403   arg2 = (int)jarg2;
82404   {
82405     try {
82406       try {
82407         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
82408       }
82409       catch(std::out_of_range &_e) {
82410         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82411         return 0;
82412       }
82413
82414     } catch (std::out_of_range& e) {
82415       {
82416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82417       };
82418     } catch (std::exception& e) {
82419       {
82420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82421       };
82422     } catch (...) {
82423       {
82424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82425       };
82426     }
82427   }
82428   jresult = result;
82429   return jresult;
82430 }
82431
82432
82433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
82434   unsigned int jresult ;
82435   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82436   int arg2 ;
82437   unsigned int *result = 0 ;
82438
82439   arg1 = (std::vector< unsigned int > *)jarg1;
82440   arg2 = (int)jarg2;
82441   {
82442     try {
82443       try {
82444         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
82445       }
82446       catch(std::out_of_range &_e) {
82447         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82448         return 0;
82449       }
82450
82451     } catch (std::out_of_range& e) {
82452       {
82453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82454       };
82455     } catch (std::exception& e) {
82456       {
82457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82458       };
82459     } catch (...) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82462       };
82463     }
82464   }
82465   jresult = *result;
82466   return jresult;
82467 }
82468
82469
82470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
82471   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82472   int arg2 ;
82473   unsigned int *arg3 = 0 ;
82474   unsigned int temp3 ;
82475
82476   arg1 = (std::vector< unsigned int > *)jarg1;
82477   arg2 = (int)jarg2;
82478   temp3 = (unsigned int)jarg3;
82479   arg3 = &temp3;
82480   {
82481     try {
82482       try {
82483         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
82484       }
82485       catch(std::out_of_range &_e) {
82486         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82487         return ;
82488       }
82489
82490     } catch (std::out_of_range& e) {
82491       {
82492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82493       };
82494     } catch (std::exception& e) {
82495       {
82496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82497       };
82498     } catch (...) {
82499       {
82500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82501       };
82502     }
82503   }
82504 }
82505
82506
82507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
82508   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82509   std::vector< unsigned int > *arg2 = 0 ;
82510
82511   arg1 = (std::vector< unsigned int > *)jarg1;
82512   arg2 = (std::vector< unsigned int > *)jarg2;
82513   if (!arg2) {
82514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82515     return ;
82516   }
82517   {
82518     try {
82519       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
82520     } catch (std::out_of_range& e) {
82521       {
82522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82523       };
82524     } catch (std::exception& e) {
82525       {
82526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82527       };
82528     } catch (...) {
82529       {
82530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82531       };
82532     }
82533   }
82534 }
82535
82536
82537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82538   void * jresult ;
82539   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82540   int arg2 ;
82541   int arg3 ;
82542   std::vector< unsigned int > *result = 0 ;
82543
82544   arg1 = (std::vector< unsigned int > *)jarg1;
82545   arg2 = (int)jarg2;
82546   arg3 = (int)jarg3;
82547   {
82548     try {
82549       try {
82550         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
82551       }
82552       catch(std::out_of_range &_e) {
82553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82554         return 0;
82555       }
82556       catch(std::invalid_argument &_e) {
82557         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82558         return 0;
82559       }
82560
82561     } catch (std::out_of_range& e) {
82562       {
82563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82564       };
82565     } catch (std::exception& e) {
82566       {
82567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82568       };
82569     } catch (...) {
82570       {
82571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82572       };
82573     }
82574   }
82575   jresult = (void *)result;
82576   return jresult;
82577 }
82578
82579
82580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
82581   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82582   int arg2 ;
82583   unsigned int *arg3 = 0 ;
82584   unsigned int temp3 ;
82585
82586   arg1 = (std::vector< unsigned int > *)jarg1;
82587   arg2 = (int)jarg2;
82588   temp3 = (unsigned int)jarg3;
82589   arg3 = &temp3;
82590   {
82591     try {
82592       try {
82593         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
82594       }
82595       catch(std::out_of_range &_e) {
82596         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82597         return ;
82598       }
82599
82600     } catch (std::out_of_range& e) {
82601       {
82602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82603       };
82604     } catch (std::exception& e) {
82605       {
82606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82607       };
82608     } catch (...) {
82609       {
82610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82611       };
82612     }
82613   }
82614 }
82615
82616
82617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82618   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82619   int arg2 ;
82620   std::vector< unsigned int > *arg3 = 0 ;
82621
82622   arg1 = (std::vector< unsigned int > *)jarg1;
82623   arg2 = (int)jarg2;
82624   arg3 = (std::vector< unsigned int > *)jarg3;
82625   if (!arg3) {
82626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82627     return ;
82628   }
82629   {
82630     try {
82631       try {
82632         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
82633       }
82634       catch(std::out_of_range &_e) {
82635         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82636         return ;
82637       }
82638
82639     } catch (std::out_of_range& e) {
82640       {
82641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (std::exception& e) {
82644       {
82645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82646       };
82647     } catch (...) {
82648       {
82649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82650       };
82651     }
82652   }
82653 }
82654
82655
82656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
82657   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82658   int arg2 ;
82659
82660   arg1 = (std::vector< unsigned int > *)jarg1;
82661   arg2 = (int)jarg2;
82662   {
82663     try {
82664       try {
82665         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
82666       }
82667       catch(std::out_of_range &_e) {
82668         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82669         return ;
82670       }
82671
82672     } catch (std::out_of_range& e) {
82673       {
82674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82675       };
82676     } catch (std::exception& e) {
82677       {
82678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82679       };
82680     } catch (...) {
82681       {
82682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82683       };
82684     }
82685   }
82686 }
82687
82688
82689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82690   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82691   int arg2 ;
82692   int arg3 ;
82693
82694   arg1 = (std::vector< unsigned int > *)jarg1;
82695   arg2 = (int)jarg2;
82696   arg3 = (int)jarg3;
82697   {
82698     try {
82699       try {
82700         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
82701       }
82702       catch(std::out_of_range &_e) {
82703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82704         return ;
82705       }
82706       catch(std::invalid_argument &_e) {
82707         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82708         return ;
82709       }
82710
82711     } catch (std::out_of_range& e) {
82712       {
82713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82714       };
82715     } catch (std::exception& e) {
82716       {
82717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82718       };
82719     } catch (...) {
82720       {
82721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82722       };
82723     }
82724   }
82725 }
82726
82727
82728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
82729   void * jresult ;
82730   unsigned int *arg1 = 0 ;
82731   int arg2 ;
82732   unsigned int temp1 ;
82733   std::vector< unsigned int > *result = 0 ;
82734
82735   temp1 = (unsigned int)jarg1;
82736   arg1 = &temp1;
82737   arg2 = (int)jarg2;
82738   {
82739     try {
82740       try {
82741         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
82742       }
82743       catch(std::out_of_range &_e) {
82744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82745         return 0;
82746       }
82747
82748     } catch (std::out_of_range& e) {
82749       {
82750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82751       };
82752     } catch (std::exception& e) {
82753       {
82754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82755       };
82756     } catch (...) {
82757       {
82758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82759       };
82760     }
82761   }
82762   jresult = (void *)result;
82763   return jresult;
82764 }
82765
82766
82767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
82768   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82769
82770   arg1 = (std::vector< unsigned int > *)jarg1;
82771   {
82772     try {
82773       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
82774     } catch (std::out_of_range& e) {
82775       {
82776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82777       };
82778     } catch (std::exception& e) {
82779       {
82780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82781       };
82782     } catch (...) {
82783       {
82784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82785       };
82786     }
82787   }
82788 }
82789
82790
82791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82792   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82793   int arg2 ;
82794   int arg3 ;
82795
82796   arg1 = (std::vector< unsigned int > *)jarg1;
82797   arg2 = (int)jarg2;
82798   arg3 = (int)jarg3;
82799   {
82800     try {
82801       try {
82802         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82803       }
82804       catch(std::out_of_range &_e) {
82805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82806         return ;
82807       }
82808       catch(std::invalid_argument &_e) {
82809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82810         return ;
82811       }
82812
82813     } catch (std::out_of_range& e) {
82814       {
82815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82816       };
82817     } catch (std::exception& e) {
82818       {
82819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82820       };
82821     } catch (...) {
82822       {
82823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82824       };
82825     }
82826   }
82827 }
82828
82829
82830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82831   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82832   int arg2 ;
82833   std::vector< unsigned int > *arg3 = 0 ;
82834
82835   arg1 = (std::vector< unsigned int > *)jarg1;
82836   arg2 = (int)jarg2;
82837   arg3 = (std::vector< unsigned int > *)jarg3;
82838   if (!arg3) {
82839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82840     return ;
82841   }
82842   {
82843     try {
82844       try {
82845         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
82846       }
82847       catch(std::out_of_range &_e) {
82848         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82849         return ;
82850       }
82851
82852     } catch (std::out_of_range& e) {
82853       {
82854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82855       };
82856     } catch (std::exception& e) {
82857       {
82858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82859       };
82860     } catch (...) {
82861       {
82862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82863       };
82864     }
82865   }
82866 }
82867
82868
82869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
82870   unsigned int jresult ;
82871   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82872   unsigned int *arg2 = 0 ;
82873   unsigned int temp2 ;
82874   bool result;
82875
82876   arg1 = (std::vector< unsigned int > *)jarg1;
82877   temp2 = (unsigned int)jarg2;
82878   arg2 = &temp2;
82879   {
82880     try {
82881       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
82882     } catch (std::out_of_range& e) {
82883       {
82884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82885       };
82886     } catch (std::exception& e) {
82887       {
82888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82889       };
82890     } catch (...) {
82891       {
82892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82893       };
82894     }
82895   }
82896   jresult = result;
82897   return jresult;
82898 }
82899
82900
82901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
82902   int jresult ;
82903   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82904   unsigned int *arg2 = 0 ;
82905   unsigned int temp2 ;
82906   int result;
82907
82908   arg1 = (std::vector< unsigned int > *)jarg1;
82909   temp2 = (unsigned int)jarg2;
82910   arg2 = &temp2;
82911   {
82912     try {
82913       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
82914     } catch (std::out_of_range& e) {
82915       {
82916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82917       };
82918     } catch (std::exception& e) {
82919       {
82920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82921       };
82922     } catch (...) {
82923       {
82924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82925       };
82926     }
82927   }
82928   jresult = result;
82929   return jresult;
82930 }
82931
82932
82933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
82934   int jresult ;
82935   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82936   unsigned int *arg2 = 0 ;
82937   unsigned int temp2 ;
82938   int result;
82939
82940   arg1 = (std::vector< unsigned int > *)jarg1;
82941   temp2 = (unsigned int)jarg2;
82942   arg2 = &temp2;
82943   {
82944     try {
82945       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
82946     } catch (std::out_of_range& e) {
82947       {
82948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82949       };
82950     } catch (std::exception& e) {
82951       {
82952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82953       };
82954     } catch (...) {
82955       {
82956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82957       };
82958     }
82959   }
82960   jresult = result;
82961   return jresult;
82962 }
82963
82964
82965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
82966   unsigned int jresult ;
82967   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82968   unsigned int *arg2 = 0 ;
82969   unsigned int temp2 ;
82970   bool result;
82971
82972   arg1 = (std::vector< unsigned int > *)jarg1;
82973   temp2 = (unsigned int)jarg2;
82974   arg2 = &temp2;
82975   {
82976     try {
82977       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
82978     } catch (std::out_of_range& e) {
82979       {
82980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82981       };
82982     } catch (std::exception& e) {
82983       {
82984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82985       };
82986     } catch (...) {
82987       {
82988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82989       };
82990     }
82991   }
82992   jresult = result;
82993   return jresult;
82994 }
82995
82996
82997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
82998   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82999
83000   arg1 = (std::vector< unsigned int > *)jarg1;
83001   {
83002     try {
83003       delete arg1;
83004     } catch (std::out_of_range& e) {
83005       {
83006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83007       };
83008     } catch (std::exception& e) {
83009       {
83010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83011       };
83012     } catch (...) {
83013       {
83014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83015       };
83016     }
83017   }
83018 }
83019
83020
83021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
83022   void * jresult ;
83023   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83024
83025   {
83026     try {
83027       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
83028     } catch (std::out_of_range& e) {
83029       {
83030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83031       };
83032     } catch (std::exception& e) {
83033       {
83034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83035       };
83036     } catch (...) {
83037       {
83038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83039       };
83040     }
83041   }
83042   jresult = (void *)result;
83043   return jresult;
83044 }
83045
83046
83047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
83048   void * jresult ;
83049   unsigned int arg1 ;
83050   Dali::Actor arg2 ;
83051   Dali::Actor *argp2 ;
83052   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83053
83054   arg1 = (unsigned int)jarg1;
83055   argp2 = (Dali::Actor *)jarg2;
83056   if (!argp2) {
83057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83058     return 0;
83059   }
83060   arg2 = *argp2;
83061   {
83062     try {
83063       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
83064     } catch (std::out_of_range& e) {
83065       {
83066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83067       };
83068     } catch (std::exception& e) {
83069       {
83070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83071       };
83072     } catch (...) {
83073       {
83074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83075       };
83076     }
83077   }
83078   jresult = (void *)result;
83079   return jresult;
83080 }
83081
83082
83083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
83084   void * jresult ;
83085   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
83086   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83087
83088   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83089   if (!arg1) {
83090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83091     return 0;
83092   }
83093   {
83094     try {
83095       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
83096     } catch (std::out_of_range& e) {
83097       {
83098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83099       };
83100     } catch (std::exception& e) {
83101       {
83102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83103       };
83104     } catch (...) {
83105       {
83106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83107       };
83108     }
83109   }
83110   jresult = (void *)result;
83111   return jresult;
83112 }
83113
83114
83115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
83116   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83117   unsigned int arg2 ;
83118
83119   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83120   arg2 = (unsigned int)jarg2;
83121   if (arg1) (arg1)->first = arg2;
83122 }
83123
83124
83125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
83126   unsigned int jresult ;
83127   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83128   unsigned int result;
83129
83130   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83131   result = (unsigned int) ((arg1)->first);
83132   jresult = result;
83133   return jresult;
83134 }
83135
83136
83137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
83138   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83139   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
83140
83141   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83142   arg2 = (Dali::Actor *)jarg2;
83143   if (arg1) (arg1)->second = *arg2;
83144 }
83145
83146
83147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
83148   void * jresult ;
83149   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83150   Dali::Actor *result = 0 ;
83151
83152   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83153   result = (Dali::Actor *)& ((arg1)->second);
83154   jresult = (void *)result;
83155   return jresult;
83156 }
83157
83158
83159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
83160   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83161
83162   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83163   {
83164     try {
83165       delete arg1;
83166     } catch (std::out_of_range& e) {
83167       {
83168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83169       };
83170     } catch (std::exception& e) {
83171       {
83172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83173       };
83174     } catch (...) {
83175       {
83176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83177       };
83178     }
83179   }
83180 }
83181
83182
83183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
83184   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83185
83186   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83187   {
83188     try {
83189       (arg1)->clear();
83190     } catch (std::out_of_range& e) {
83191       {
83192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83193       };
83194     } catch (std::exception& e) {
83195       {
83196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83197       };
83198     } catch (...) {
83199       {
83200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83201       };
83202     }
83203   }
83204 }
83205
83206
83207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
83208   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83209   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
83210
83211   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83212   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
83213   if (!arg2) {
83214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83215     return ;
83216   }
83217   {
83218     try {
83219       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
83220     } catch (std::out_of_range& e) {
83221       {
83222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83223       };
83224     } catch (std::exception& e) {
83225       {
83226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83227       };
83228     } catch (...) {
83229       {
83230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83231       };
83232     }
83233   }
83234 }
83235
83236
83237 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
83238   unsigned long jresult ;
83239   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83240   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
83241
83242   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83243   {
83244     try {
83245       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
83246     } catch (std::out_of_range& e) {
83247       {
83248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83249       };
83250     } catch (std::exception& e) {
83251       {
83252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83253       };
83254     } catch (...) {
83255       {
83256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83257       };
83258     }
83259   }
83260   jresult = (unsigned long)result;
83261   return jresult;
83262 }
83263
83264
83265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
83266   unsigned long jresult ;
83267   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83268   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
83269
83270   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83271   {
83272     try {
83273       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
83274     } catch (std::out_of_range& e) {
83275       {
83276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83277       };
83278     } catch (std::exception& e) {
83279       {
83280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83281       };
83282     } catch (...) {
83283       {
83284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83285       };
83286     }
83287   }
83288   jresult = (unsigned long)result;
83289   return jresult;
83290 }
83291
83292
83293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
83294   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83295   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
83296
83297   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83298   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
83299   {
83300     try {
83301       (arg1)->reserve(arg2);
83302     } catch (std::out_of_range& e) {
83303       {
83304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83305       };
83306     } catch (std::exception& e) {
83307       {
83308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83309       };
83310     } catch (...) {
83311       {
83312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83313       };
83314     }
83315   }
83316 }
83317
83318
83319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
83320   void * jresult ;
83321   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83322
83323   {
83324     try {
83325       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
83326     } catch (std::out_of_range& e) {
83327       {
83328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83329       };
83330     } catch (std::exception& e) {
83331       {
83332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83333       };
83334     } catch (...) {
83335       {
83336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83337       };
83338     }
83339   }
83340   jresult = (void *)result;
83341   return jresult;
83342 }
83343
83344
83345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
83346   void * jresult ;
83347   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
83348   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83349
83350   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83351   if (!arg1) {
83352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83353     return 0;
83354   }
83355   {
83356     try {
83357       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);
83358     } catch (std::out_of_range& e) {
83359       {
83360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83361       };
83362     } catch (std::exception& e) {
83363       {
83364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83365       };
83366     } catch (...) {
83367       {
83368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83369       };
83370     }
83371   }
83372   jresult = (void *)result;
83373   return jresult;
83374 }
83375
83376
83377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
83378   void * jresult ;
83379   int arg1 ;
83380   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83381
83382   arg1 = (int)jarg1;
83383   {
83384     try {
83385       try {
83386         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);
83387       }
83388       catch(std::out_of_range &_e) {
83389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83390         return 0;
83391       }
83392
83393     } catch (std::out_of_range& e) {
83394       {
83395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83396       };
83397     } catch (std::exception& e) {
83398       {
83399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83400       };
83401     } catch (...) {
83402       {
83403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83404       };
83405     }
83406   }
83407   jresult = (void *)result;
83408   return jresult;
83409 }
83410
83411
83412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
83413   void * jresult ;
83414   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83415   int arg2 ;
83416   std::pair< unsigned int,Dali::Actor > result;
83417
83418   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83419   arg2 = (int)jarg2;
83420   {
83421     try {
83422       try {
83423         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
83424       }
83425       catch(std::out_of_range &_e) {
83426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83427         return 0;
83428       }
83429
83430     } catch (std::out_of_range& e) {
83431       {
83432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83433       };
83434     } catch (std::exception& e) {
83435       {
83436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83437       };
83438     } catch (...) {
83439       {
83440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83441       };
83442     }
83443   }
83444   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
83445   return jresult;
83446 }
83447
83448
83449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
83450   void * jresult ;
83451   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83452   int arg2 ;
83453   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83454
83455   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83456   arg2 = (int)jarg2;
83457   {
83458     try {
83459       try {
83460         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
83461       }
83462       catch(std::out_of_range &_e) {
83463         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83464         return 0;
83465       }
83466
83467     } catch (std::out_of_range& e) {
83468       {
83469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83470       };
83471     } catch (std::exception& e) {
83472       {
83473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83474       };
83475     } catch (...) {
83476       {
83477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83478       };
83479     }
83480   }
83481   jresult = (void *)result;
83482   return jresult;
83483 }
83484
83485
83486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
83487   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83488   int arg2 ;
83489   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
83490
83491   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83492   arg2 = (int)jarg2;
83493   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
83494   if (!arg3) {
83495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83496     return ;
83497   }
83498   {
83499     try {
83500       try {
83501         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);
83502       }
83503       catch(std::out_of_range &_e) {
83504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83505         return ;
83506       }
83507
83508     } catch (std::out_of_range& e) {
83509       {
83510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83511       };
83512     } catch (std::exception& e) {
83513       {
83514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83515       };
83516     } catch (...) {
83517       {
83518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83519       };
83520     }
83521   }
83522 }
83523
83524
83525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
83526   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83527   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
83528
83529   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83530   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
83531   if (!arg2) {
83532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83533     return ;
83534   }
83535   {
83536     try {
83537       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);
83538     } catch (std::out_of_range& e) {
83539       {
83540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83541       };
83542     } catch (std::exception& e) {
83543       {
83544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83545       };
83546     } catch (...) {
83547       {
83548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83549       };
83550     }
83551   }
83552 }
83553
83554
83555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
83556   void * jresult ;
83557   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83558   int arg2 ;
83559   int arg3 ;
83560   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83561
83562   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83563   arg2 = (int)jarg2;
83564   arg3 = (int)jarg3;
83565   {
83566     try {
83567       try {
83568         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);
83569       }
83570       catch(std::out_of_range &_e) {
83571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83572         return 0;
83573       }
83574       catch(std::invalid_argument &_e) {
83575         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83576         return 0;
83577       }
83578
83579     } catch (std::out_of_range& e) {
83580       {
83581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83582       };
83583     } catch (std::exception& e) {
83584       {
83585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83586       };
83587     } catch (...) {
83588       {
83589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83590       };
83591     }
83592   }
83593   jresult = (void *)result;
83594   return jresult;
83595 }
83596
83597
83598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
83599   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83600   int arg2 ;
83601   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
83602
83603   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83604   arg2 = (int)jarg2;
83605   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
83606   if (!arg3) {
83607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83608     return ;
83609   }
83610   {
83611     try {
83612       try {
83613         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);
83614       }
83615       catch(std::out_of_range &_e) {
83616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83617         return ;
83618       }
83619
83620     } catch (std::out_of_range& e) {
83621       {
83622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83623       };
83624     } catch (std::exception& e) {
83625       {
83626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83627       };
83628     } catch (...) {
83629       {
83630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83631       };
83632     }
83633   }
83634 }
83635
83636
83637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
83638   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83639   int arg2 ;
83640   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
83641
83642   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83643   arg2 = (int)jarg2;
83644   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
83645   if (!arg3) {
83646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83647     return ;
83648   }
83649   {
83650     try {
83651       try {
83652         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);
83653       }
83654       catch(std::out_of_range &_e) {
83655         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83656         return ;
83657       }
83658
83659     } catch (std::out_of_range& e) {
83660       {
83661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83662       };
83663     } catch (std::exception& e) {
83664       {
83665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83666       };
83667     } catch (...) {
83668       {
83669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83670       };
83671     }
83672   }
83673 }
83674
83675
83676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
83677   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83678   int arg2 ;
83679
83680   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83681   arg2 = (int)jarg2;
83682   {
83683     try {
83684       try {
83685         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
83686       }
83687       catch(std::out_of_range &_e) {
83688         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83689         return ;
83690       }
83691
83692     } catch (std::out_of_range& e) {
83693       {
83694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83695       };
83696     } catch (std::exception& e) {
83697       {
83698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83699       };
83700     } catch (...) {
83701       {
83702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83703       };
83704     }
83705   }
83706 }
83707
83708
83709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
83710   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83711   int arg2 ;
83712   int arg3 ;
83713
83714   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83715   arg2 = (int)jarg2;
83716   arg3 = (int)jarg3;
83717   {
83718     try {
83719       try {
83720         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
83721       }
83722       catch(std::out_of_range &_e) {
83723         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83724         return ;
83725       }
83726       catch(std::invalid_argument &_e) {
83727         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83728         return ;
83729       }
83730
83731     } catch (std::out_of_range& e) {
83732       {
83733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83734       };
83735     } catch (std::exception& e) {
83736       {
83737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83738       };
83739     } catch (...) {
83740       {
83741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83742       };
83743     }
83744   }
83745 }
83746
83747
83748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
83749   void * jresult ;
83750   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
83751   int arg2 ;
83752   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83753
83754   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83755   if (!arg1) {
83756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83757     return 0;
83758   }
83759   arg2 = (int)jarg2;
83760   {
83761     try {
83762       try {
83763         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);
83764       }
83765       catch(std::out_of_range &_e) {
83766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83767         return 0;
83768       }
83769
83770     } catch (std::out_of_range& e) {
83771       {
83772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83773       };
83774     } catch (std::exception& e) {
83775       {
83776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83777       };
83778     } catch (...) {
83779       {
83780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83781       };
83782     }
83783   }
83784   jresult = (void *)result;
83785   return jresult;
83786 }
83787
83788
83789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
83790   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83791
83792   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83793   {
83794     try {
83795       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
83796     } catch (std::out_of_range& e) {
83797       {
83798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83799       };
83800     } catch (std::exception& e) {
83801       {
83802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83803       };
83804     } catch (...) {
83805       {
83806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83807       };
83808     }
83809   }
83810 }
83811
83812
83813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
83814   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83815   int arg2 ;
83816   int arg3 ;
83817
83818   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83819   arg2 = (int)jarg2;
83820   arg3 = (int)jarg3;
83821   {
83822     try {
83823       try {
83824         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
83825       }
83826       catch(std::out_of_range &_e) {
83827         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83828         return ;
83829       }
83830       catch(std::invalid_argument &_e) {
83831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83832         return ;
83833       }
83834
83835     } catch (std::out_of_range& e) {
83836       {
83837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83838       };
83839     } catch (std::exception& e) {
83840       {
83841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83842       };
83843     } catch (...) {
83844       {
83845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83846       };
83847     }
83848   }
83849 }
83850
83851
83852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
83853   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83854   int arg2 ;
83855   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
83856
83857   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83858   arg2 = (int)jarg2;
83859   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
83860   if (!arg3) {
83861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83862     return ;
83863   }
83864   {
83865     try {
83866       try {
83867         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);
83868       }
83869       catch(std::out_of_range &_e) {
83870         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83871         return ;
83872       }
83873
83874     } catch (std::out_of_range& e) {
83875       {
83876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83877       };
83878     } catch (std::exception& e) {
83879       {
83880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83881       };
83882     } catch (...) {
83883       {
83884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83885       };
83886     }
83887   }
83888 }
83889
83890
83891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
83892   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83893
83894   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83895   {
83896     try {
83897       delete arg1;
83898     } catch (std::out_of_range& e) {
83899       {
83900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83901       };
83902     } catch (std::exception& e) {
83903       {
83904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83905       };
83906     } catch (...) {
83907       {
83908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83909       };
83910     }
83911   }
83912 }
83913
83914
83915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
83916   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83917
83918   arg1 = (std::vector< Dali::Actor > *)jarg1;
83919   {
83920     try {
83921       (arg1)->clear();
83922     } catch (std::out_of_range& e) {
83923       {
83924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83925       };
83926     } catch (std::exception& e) {
83927       {
83928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83929       };
83930     } catch (...) {
83931       {
83932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83933       };
83934     }
83935   }
83936 }
83937
83938
83939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
83940   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83941   Dali::Actor *arg2 = 0 ;
83942
83943   arg1 = (std::vector< Dali::Actor > *)jarg1;
83944   arg2 = (Dali::Actor *)jarg2;
83945   if (!arg2) {
83946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
83947     return ;
83948   }
83949   {
83950     try {
83951       (arg1)->push_back((Dali::Actor const &)*arg2);
83952     } catch (std::out_of_range& e) {
83953       {
83954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83955       };
83956     } catch (std::exception& e) {
83957       {
83958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83959       };
83960     } catch (...) {
83961       {
83962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83963       };
83964     }
83965   }
83966 }
83967
83968
83969 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
83970   unsigned long jresult ;
83971   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
83972   std::vector< Dali::Actor >::size_type result;
83973
83974   arg1 = (std::vector< Dali::Actor > *)jarg1;
83975   {
83976     try {
83977       result = ((std::vector< Dali::Actor > const *)arg1)->size();
83978     } catch (std::out_of_range& e) {
83979       {
83980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83981       };
83982     } catch (std::exception& e) {
83983       {
83984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83985       };
83986     } catch (...) {
83987       {
83988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83989       };
83990     }
83991   }
83992   jresult = (unsigned long)result;
83993   return jresult;
83994 }
83995
83996
83997 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
83998   unsigned long jresult ;
83999   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84000   std::vector< Dali::Actor >::size_type result;
84001
84002   arg1 = (std::vector< Dali::Actor > *)jarg1;
84003   {
84004     try {
84005       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
84006     } catch (std::out_of_range& e) {
84007       {
84008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84009       };
84010     } catch (std::exception& e) {
84011       {
84012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84013       };
84014     } catch (...) {
84015       {
84016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84017       };
84018     }
84019   }
84020   jresult = (unsigned long)result;
84021   return jresult;
84022 }
84023
84024
84025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
84026   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84027   std::vector< Dali::Actor >::size_type arg2 ;
84028
84029   arg1 = (std::vector< Dali::Actor > *)jarg1;
84030   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
84031   {
84032     try {
84033       (arg1)->reserve(arg2);
84034     } catch (std::out_of_range& e) {
84035       {
84036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84037       };
84038     } catch (std::exception& e) {
84039       {
84040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84041       };
84042     } catch (...) {
84043       {
84044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84045       };
84046     }
84047   }
84048 }
84049
84050
84051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
84052   void * jresult ;
84053   std::vector< Dali::Actor > *result = 0 ;
84054
84055   {
84056     try {
84057       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
84058     } catch (std::out_of_range& e) {
84059       {
84060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84061       };
84062     } catch (std::exception& e) {
84063       {
84064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84065       };
84066     } catch (...) {
84067       {
84068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84069       };
84070     }
84071   }
84072   jresult = (void *)result;
84073   return jresult;
84074 }
84075
84076
84077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
84078   void * jresult ;
84079   std::vector< Dali::Actor > *arg1 = 0 ;
84080   std::vector< Dali::Actor > *result = 0 ;
84081
84082   arg1 = (std::vector< Dali::Actor > *)jarg1;
84083   if (!arg1) {
84084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84085     return 0;
84086   }
84087   {
84088     try {
84089       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
84090     } catch (std::out_of_range& e) {
84091       {
84092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84093       };
84094     } catch (std::exception& e) {
84095       {
84096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84097       };
84098     } catch (...) {
84099       {
84100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84101       };
84102     }
84103   }
84104   jresult = (void *)result;
84105   return jresult;
84106 }
84107
84108
84109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
84110   void * jresult ;
84111   int arg1 ;
84112   std::vector< Dali::Actor > *result = 0 ;
84113
84114   arg1 = (int)jarg1;
84115   {
84116     try {
84117       try {
84118         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
84119       }
84120       catch(std::out_of_range &_e) {
84121         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84122         return 0;
84123       }
84124
84125     } catch (std::out_of_range& e) {
84126       {
84127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84128       };
84129     } catch (std::exception& e) {
84130       {
84131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84132       };
84133     } catch (...) {
84134       {
84135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84136       };
84137     }
84138   }
84139   jresult = (void *)result;
84140   return jresult;
84141 }
84142
84143
84144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
84145   void * jresult ;
84146   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84147   int arg2 ;
84148   Dali::Actor result;
84149
84150   arg1 = (std::vector< Dali::Actor > *)jarg1;
84151   arg2 = (int)jarg2;
84152   {
84153     try {
84154       try {
84155         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
84156       }
84157       catch(std::out_of_range &_e) {
84158         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84159         return 0;
84160       }
84161
84162     } catch (std::out_of_range& e) {
84163       {
84164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84165       };
84166     } catch (std::exception& e) {
84167       {
84168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84169       };
84170     } catch (...) {
84171       {
84172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84173       };
84174     }
84175   }
84176   jresult = new Dali::Actor((const Dali::Actor &)result);
84177   return jresult;
84178 }
84179
84180
84181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
84182   void * jresult ;
84183   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84184   int arg2 ;
84185   Dali::Actor *result = 0 ;
84186
84187   arg1 = (std::vector< Dali::Actor > *)jarg1;
84188   arg2 = (int)jarg2;
84189   {
84190     try {
84191       try {
84192         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
84193       }
84194       catch(std::out_of_range &_e) {
84195         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84196         return 0;
84197       }
84198
84199     } catch (std::out_of_range& e) {
84200       {
84201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84202       };
84203     } catch (std::exception& e) {
84204       {
84205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84206       };
84207     } catch (...) {
84208       {
84209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84210       };
84211     }
84212   }
84213   jresult = (void *)result;
84214   return jresult;
84215 }
84216
84217
84218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
84219   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84220   int arg2 ;
84221   Dali::Actor *arg3 = 0 ;
84222
84223   arg1 = (std::vector< Dali::Actor > *)jarg1;
84224   arg2 = (int)jarg2;
84225   arg3 = (Dali::Actor *)jarg3;
84226   if (!arg3) {
84227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84228     return ;
84229   }
84230   {
84231     try {
84232       try {
84233         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
84234       }
84235       catch(std::out_of_range &_e) {
84236         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84237         return ;
84238       }
84239
84240     } catch (std::out_of_range& e) {
84241       {
84242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84243       };
84244     } catch (std::exception& e) {
84245       {
84246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84247       };
84248     } catch (...) {
84249       {
84250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84251       };
84252     }
84253   }
84254 }
84255
84256
84257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
84258   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84259   std::vector< Dali::Actor > *arg2 = 0 ;
84260
84261   arg1 = (std::vector< Dali::Actor > *)jarg1;
84262   arg2 = (std::vector< Dali::Actor > *)jarg2;
84263   if (!arg2) {
84264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84265     return ;
84266   }
84267   {
84268     try {
84269       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
84270     } catch (std::out_of_range& e) {
84271       {
84272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84273       };
84274     } catch (std::exception& e) {
84275       {
84276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84277       };
84278     } catch (...) {
84279       {
84280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84281       };
84282     }
84283   }
84284 }
84285
84286
84287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
84288   void * jresult ;
84289   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84290   int arg2 ;
84291   int arg3 ;
84292   std::vector< Dali::Actor > *result = 0 ;
84293
84294   arg1 = (std::vector< Dali::Actor > *)jarg1;
84295   arg2 = (int)jarg2;
84296   arg3 = (int)jarg3;
84297   {
84298     try {
84299       try {
84300         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
84301       }
84302       catch(std::out_of_range &_e) {
84303         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84304         return 0;
84305       }
84306       catch(std::invalid_argument &_e) {
84307         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84308         return 0;
84309       }
84310
84311     } catch (std::out_of_range& e) {
84312       {
84313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84314       };
84315     } catch (std::exception& e) {
84316       {
84317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84318       };
84319     } catch (...) {
84320       {
84321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84322       };
84323     }
84324   }
84325   jresult = (void *)result;
84326   return jresult;
84327 }
84328
84329
84330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
84331   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84332   int arg2 ;
84333   Dali::Actor *arg3 = 0 ;
84334
84335   arg1 = (std::vector< Dali::Actor > *)jarg1;
84336   arg2 = (int)jarg2;
84337   arg3 = (Dali::Actor *)jarg3;
84338   if (!arg3) {
84339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84340     return ;
84341   }
84342   {
84343     try {
84344       try {
84345         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
84346       }
84347       catch(std::out_of_range &_e) {
84348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84349         return ;
84350       }
84351
84352     } catch (std::out_of_range& e) {
84353       {
84354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84355       };
84356     } catch (std::exception& e) {
84357       {
84358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84359       };
84360     } catch (...) {
84361       {
84362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84363       };
84364     }
84365   }
84366 }
84367
84368
84369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
84370   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84371   int arg2 ;
84372   std::vector< Dali::Actor > *arg3 = 0 ;
84373
84374   arg1 = (std::vector< Dali::Actor > *)jarg1;
84375   arg2 = (int)jarg2;
84376   arg3 = (std::vector< Dali::Actor > *)jarg3;
84377   if (!arg3) {
84378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84379     return ;
84380   }
84381   {
84382     try {
84383       try {
84384         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
84385       }
84386       catch(std::out_of_range &_e) {
84387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84388         return ;
84389       }
84390
84391     } catch (std::out_of_range& e) {
84392       {
84393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84394       };
84395     } catch (std::exception& e) {
84396       {
84397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84398       };
84399     } catch (...) {
84400       {
84401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84402       };
84403     }
84404   }
84405 }
84406
84407
84408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
84409   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84410   int arg2 ;
84411
84412   arg1 = (std::vector< Dali::Actor > *)jarg1;
84413   arg2 = (int)jarg2;
84414   {
84415     try {
84416       try {
84417         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
84418       }
84419       catch(std::out_of_range &_e) {
84420         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84421         return ;
84422       }
84423
84424     } catch (std::out_of_range& e) {
84425       {
84426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84427       };
84428     } catch (std::exception& e) {
84429       {
84430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84431       };
84432     } catch (...) {
84433       {
84434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84435       };
84436     }
84437   }
84438 }
84439
84440
84441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
84442   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84443   int arg2 ;
84444   int arg3 ;
84445
84446   arg1 = (std::vector< Dali::Actor > *)jarg1;
84447   arg2 = (int)jarg2;
84448   arg3 = (int)jarg3;
84449   {
84450     try {
84451       try {
84452         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
84453       }
84454       catch(std::out_of_range &_e) {
84455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84456         return ;
84457       }
84458       catch(std::invalid_argument &_e) {
84459         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84460         return ;
84461       }
84462
84463     } catch (std::out_of_range& e) {
84464       {
84465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84466       };
84467     } catch (std::exception& e) {
84468       {
84469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84470       };
84471     } catch (...) {
84472       {
84473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84474       };
84475     }
84476   }
84477 }
84478
84479
84480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
84481   void * jresult ;
84482   Dali::Actor *arg1 = 0 ;
84483   int arg2 ;
84484   std::vector< Dali::Actor > *result = 0 ;
84485
84486   arg1 = (Dali::Actor *)jarg1;
84487   if (!arg1) {
84488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84489     return 0;
84490   }
84491   arg2 = (int)jarg2;
84492   {
84493     try {
84494       try {
84495         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
84496       }
84497       catch(std::out_of_range &_e) {
84498         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84499         return 0;
84500       }
84501
84502     } catch (std::out_of_range& e) {
84503       {
84504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84505       };
84506     } catch (std::exception& e) {
84507       {
84508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84509       };
84510     } catch (...) {
84511       {
84512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84513       };
84514     }
84515   }
84516   jresult = (void *)result;
84517   return jresult;
84518 }
84519
84520
84521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
84522   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84523
84524   arg1 = (std::vector< Dali::Actor > *)jarg1;
84525   {
84526     try {
84527       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
84528     } catch (std::out_of_range& e) {
84529       {
84530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84531       };
84532     } catch (std::exception& e) {
84533       {
84534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84535       };
84536     } catch (...) {
84537       {
84538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84539       };
84540     }
84541   }
84542 }
84543
84544
84545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
84546   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84547   int arg2 ;
84548   int arg3 ;
84549
84550   arg1 = (std::vector< Dali::Actor > *)jarg1;
84551   arg2 = (int)jarg2;
84552   arg3 = (int)jarg3;
84553   {
84554     try {
84555       try {
84556         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
84557       }
84558       catch(std::out_of_range &_e) {
84559         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84560         return ;
84561       }
84562       catch(std::invalid_argument &_e) {
84563         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84564         return ;
84565       }
84566
84567     } catch (std::out_of_range& e) {
84568       {
84569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84570       };
84571     } catch (std::exception& e) {
84572       {
84573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84574       };
84575     } catch (...) {
84576       {
84577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84578       };
84579     }
84580   }
84581 }
84582
84583
84584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
84585   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84586   int arg2 ;
84587   std::vector< Dali::Actor > *arg3 = 0 ;
84588
84589   arg1 = (std::vector< Dali::Actor > *)jarg1;
84590   arg2 = (int)jarg2;
84591   arg3 = (std::vector< Dali::Actor > *)jarg3;
84592   if (!arg3) {
84593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84594     return ;
84595   }
84596   {
84597     try {
84598       try {
84599         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
84600       }
84601       catch(std::out_of_range &_e) {
84602         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84603         return ;
84604       }
84605
84606     } catch (std::out_of_range& e) {
84607       {
84608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84609       };
84610     } catch (std::exception& e) {
84611       {
84612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84613       };
84614     } catch (...) {
84615       {
84616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84617       };
84618     }
84619   }
84620 }
84621
84622
84623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
84624   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84625
84626   arg1 = (std::vector< Dali::Actor > *)jarg1;
84627   {
84628     try {
84629       delete arg1;
84630     } catch (std::out_of_range& e) {
84631       {
84632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84633       };
84634     } catch (std::exception& e) {
84635       {
84636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84637       };
84638     } catch (...) {
84639       {
84640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84641       };
84642     }
84643   }
84644 }
84645
84646
84647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
84648   unsigned int jresult ;
84649   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84650   bool result;
84651
84652   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84653   {
84654     try {
84655       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
84656     } catch (std::out_of_range& e) {
84657       {
84658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84659       };
84660     } catch (std::exception& e) {
84661       {
84662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84663       };
84664     } catch (...) {
84665       {
84666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84667       };
84668     }
84669   }
84670   jresult = result;
84671   return jresult;
84672 }
84673
84674
84675 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
84676   unsigned long jresult ;
84677   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84678   std::size_t result;
84679
84680   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84681   {
84682     try {
84683       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
84684     } catch (std::out_of_range& e) {
84685       {
84686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84687       };
84688     } catch (std::exception& e) {
84689       {
84690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84691       };
84692     } catch (...) {
84693       {
84694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84695       };
84696     }
84697   }
84698   jresult = (unsigned long)result;
84699   return jresult;
84700 }
84701
84702
84703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
84704   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84705   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
84706
84707   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84708   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
84709   {
84710     try {
84711       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
84712     } catch (std::out_of_range& e) {
84713       {
84714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84715       };
84716     } catch (std::exception& e) {
84717       {
84718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84719       };
84720     } catch (...) {
84721       {
84722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84723       };
84724     }
84725   }
84726 }
84727
84728
84729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
84730   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84731   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
84732
84733   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84734   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
84735   {
84736     try {
84737       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
84738     } catch (std::out_of_range& e) {
84739       {
84740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84741       };
84742     } catch (std::exception& e) {
84743       {
84744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84745       };
84746     } catch (...) {
84747       {
84748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84749       };
84750     }
84751   }
84752 }
84753
84754
84755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
84756   unsigned int jresult ;
84757   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84758   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
84759   bool result;
84760
84761   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84762   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
84763   if (!arg2) {
84764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
84765     return 0;
84766   }
84767   {
84768     try {
84769       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
84770     } catch (std::out_of_range& e) {
84771       {
84772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84773       };
84774     } catch (std::exception& e) {
84775       {
84776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84777       };
84778     } catch (...) {
84779       {
84780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84781       };
84782     }
84783   }
84784   jresult = result;
84785   return jresult;
84786 }
84787
84788
84789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
84790   void * jresult ;
84791   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
84792
84793   {
84794     try {
84795       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
84796     } catch (std::out_of_range& e) {
84797       {
84798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84799       };
84800     } catch (std::exception& e) {
84801       {
84802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84803       };
84804     } catch (...) {
84805       {
84806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84807       };
84808     }
84809   }
84810   jresult = (void *)result;
84811   return jresult;
84812 }
84813
84814
84815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
84816   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84817
84818   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84819   {
84820     try {
84821       delete arg1;
84822     } catch (std::out_of_range& e) {
84823       {
84824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84825       };
84826     } catch (std::exception& e) {
84827       {
84828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84829       };
84830     } catch (...) {
84831       {
84832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84833       };
84834     }
84835   }
84836 }
84837
84838
84839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
84840   unsigned int jresult ;
84841   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84842   bool result;
84843
84844   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84845   {
84846     try {
84847       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);
84848     } catch (std::out_of_range& e) {
84849       {
84850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84851       };
84852     } catch (std::exception& e) {
84853       {
84854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84855       };
84856     } catch (...) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84859       };
84860     }
84861   }
84862   jresult = result;
84863   return jresult;
84864 }
84865
84866
84867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
84868   unsigned long jresult ;
84869   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84870   std::size_t result;
84871
84872   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84873   {
84874     try {
84875       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);
84876     } catch (std::out_of_range& e) {
84877       {
84878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84879       };
84880     } catch (std::exception& e) {
84881       {
84882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (...) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84887       };
84888     }
84889   }
84890   jresult = (unsigned long)result;
84891   return jresult;
84892 }
84893
84894
84895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
84896   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84897   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
84898
84899   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84900   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
84901   {
84902     try {
84903       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
84904     } catch (std::out_of_range& e) {
84905       {
84906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84907       };
84908     } catch (std::exception& e) {
84909       {
84910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84911       };
84912     } catch (...) {
84913       {
84914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84915       };
84916     }
84917   }
84918 }
84919
84920
84921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
84922   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84923   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
84924
84925   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84926   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
84927   {
84928     try {
84929       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
84930     } catch (std::out_of_range& e) {
84931       {
84932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84933       };
84934     } catch (std::exception& e) {
84935       {
84936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84937       };
84938     } catch (...) {
84939       {
84940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84941       };
84942     }
84943   }
84944 }
84945
84946
84947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
84948   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84949   Dali::Actor arg2 ;
84950   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
84951   Dali::Actor *argp2 ;
84952
84953   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84954   argp2 = (Dali::Actor *)jarg2;
84955   if (!argp2) {
84956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84957     return ;
84958   }
84959   arg2 = *argp2;
84960   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
84961   {
84962     try {
84963       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
84964     } catch (std::out_of_range& e) {
84965       {
84966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84967       };
84968     } catch (std::exception& e) {
84969       {
84970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84971       };
84972     } catch (...) {
84973       {
84974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84975       };
84976     }
84977   }
84978 }
84979
84980
84981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
84982   void * jresult ;
84983   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
84984
84985   {
84986     try {
84987       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
84988     } catch (std::out_of_range& e) {
84989       {
84990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84991       };
84992     } catch (std::exception& e) {
84993       {
84994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84995       };
84996     } catch (...) {
84997       {
84998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84999       };
85000     }
85001   }
85002   jresult = (void *)result;
85003   return jresult;
85004 }
85005
85006
85007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
85008   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85009
85010   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85011   {
85012     try {
85013       delete arg1;
85014     } catch (std::out_of_range& e) {
85015       {
85016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85017       };
85018     } catch (std::exception& e) {
85019       {
85020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85021       };
85022     } catch (...) {
85023       {
85024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85025       };
85026     }
85027   }
85028 }
85029
85030
85031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
85032   unsigned int jresult ;
85033   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85034   bool result;
85035
85036   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85037   {
85038     try {
85039       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
85040     } catch (std::out_of_range& e) {
85041       {
85042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85043       };
85044     } catch (std::exception& e) {
85045       {
85046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85047       };
85048     } catch (...) {
85049       {
85050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85051       };
85052     }
85053   }
85054   jresult = result;
85055   return jresult;
85056 }
85057
85058
85059 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
85060   unsigned long jresult ;
85061   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85062   std::size_t result;
85063
85064   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85065   {
85066     try {
85067       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
85068     } catch (std::out_of_range& e) {
85069       {
85070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85071       };
85072     } catch (std::exception& e) {
85073       {
85074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85075       };
85076     } catch (...) {
85077       {
85078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85079       };
85080     }
85081   }
85082   jresult = (unsigned long)result;
85083   return jresult;
85084 }
85085
85086
85087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
85088   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85089   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
85090
85091   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85092   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
85093   {
85094     try {
85095       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
85096     } catch (std::out_of_range& e) {
85097       {
85098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85099       };
85100     } catch (std::exception& e) {
85101       {
85102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85103       };
85104     } catch (...) {
85105       {
85106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85107       };
85108     }
85109   }
85110 }
85111
85112
85113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85114   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85115   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
85116
85117   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85118   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
85119   {
85120     try {
85121       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
85122     } catch (std::out_of_range& e) {
85123       {
85124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85125       };
85126     } catch (std::exception& e) {
85127       {
85128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85133       };
85134     }
85135   }
85136 }
85137
85138
85139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
85140   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85141   Dali::Actor arg2 ;
85142   Dali::Actor arg3 ;
85143   Dali::Actor *argp2 ;
85144   Dali::Actor *argp3 ;
85145
85146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85147   argp2 = (Dali::Actor *)jarg2;
85148   if (!argp2) {
85149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85150     return ;
85151   }
85152   arg2 = *argp2;
85153   argp3 = (Dali::Actor *)jarg3;
85154   if (!argp3) {
85155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85156     return ;
85157   }
85158   arg3 = *argp3;
85159   {
85160     try {
85161       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
85162     } catch (std::out_of_range& e) {
85163       {
85164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85165       };
85166     } catch (std::exception& e) {
85167       {
85168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85169       };
85170     } catch (...) {
85171       {
85172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85173       };
85174     }
85175   }
85176 }
85177
85178
85179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
85180   void * jresult ;
85181   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
85182
85183   {
85184     try {
85185       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
85186     } catch (std::out_of_range& e) {
85187       {
85188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85189       };
85190     } catch (std::exception& e) {
85191       {
85192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85193       };
85194     } catch (...) {
85195       {
85196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85197       };
85198     }
85199   }
85200   jresult = (void *)result;
85201   return jresult;
85202 }
85203
85204
85205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
85206   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85207
85208   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85209   {
85210     try {
85211       delete arg1;
85212     } catch (std::out_of_range& e) {
85213       {
85214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85215       };
85216     } catch (std::exception& e) {
85217       {
85218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85219       };
85220     } catch (...) {
85221       {
85222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85223       };
85224     }
85225   }
85226 }
85227
85228
85229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
85230   unsigned int jresult ;
85231   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85232   bool result;
85233
85234   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85235   {
85236     try {
85237       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
85238     } catch (std::out_of_range& e) {
85239       {
85240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85241       };
85242     } catch (std::exception& e) {
85243       {
85244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85245       };
85246     } catch (...) {
85247       {
85248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85249       };
85250     }
85251   }
85252   jresult = result;
85253   return jresult;
85254 }
85255
85256
85257 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
85258   unsigned long jresult ;
85259   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85260   std::size_t result;
85261
85262   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85263   {
85264     try {
85265       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
85266     } catch (std::out_of_range& e) {
85267       {
85268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85269       };
85270     } catch (std::exception& e) {
85271       {
85272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85273       };
85274     } catch (...) {
85275       {
85276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85277       };
85278     }
85279   }
85280   jresult = (unsigned long)result;
85281   return jresult;
85282 }
85283
85284
85285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
85286   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85287   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
85288
85289   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85290   arg2 = (void (*)(Dali::Actor,bool))jarg2;
85291   {
85292     try {
85293       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
85294     } catch (std::out_of_range& e) {
85295       {
85296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85297       };
85298     } catch (std::exception& e) {
85299       {
85300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85301       };
85302     } catch (...) {
85303       {
85304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85305       };
85306     }
85307   }
85308 }
85309
85310
85311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85312   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85313   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
85314
85315   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85316   arg2 = (void (*)(Dali::Actor,bool))jarg2;
85317   {
85318     try {
85319       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
85320     } catch (std::out_of_range& e) {
85321       {
85322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85323       };
85324     } catch (std::exception& e) {
85325       {
85326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85327       };
85328     } catch (...) {
85329       {
85330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85331       };
85332     }
85333   }
85334 }
85335
85336
85337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
85338   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85339   Dali::Actor arg2 ;
85340   bool arg3 ;
85341   Dali::Actor *argp2 ;
85342
85343   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85344   argp2 = (Dali::Actor *)jarg2;
85345   if (!argp2) {
85346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85347     return ;
85348   }
85349   arg2 = *argp2;
85350   arg3 = jarg3 ? true : false;
85351   {
85352     try {
85353       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
85354     } catch (std::out_of_range& e) {
85355       {
85356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85357       };
85358     } catch (std::exception& e) {
85359       {
85360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85361       };
85362     } catch (...) {
85363       {
85364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85365       };
85366     }
85367   }
85368 }
85369
85370
85371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
85372   void * jresult ;
85373   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
85374
85375   {
85376     try {
85377       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
85378     } catch (std::out_of_range& e) {
85379       {
85380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85381       };
85382     } catch (std::exception& e) {
85383       {
85384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85385       };
85386     } catch (...) {
85387       {
85388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85389       };
85390     }
85391   }
85392   jresult = (void *)result;
85393   return jresult;
85394 }
85395
85396
85397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
85398   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85399
85400   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85401   {
85402     try {
85403       delete arg1;
85404     } catch (std::out_of_range& e) {
85405       {
85406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85407       };
85408     } catch (std::exception& e) {
85409       {
85410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85411       };
85412     } catch (...) {
85413       {
85414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85415       };
85416     }
85417   }
85418 }
85419
85420
85421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
85422   unsigned int jresult ;
85423   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85424   bool result;
85425
85426   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85427   {
85428     try {
85429       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);
85430     } catch (std::out_of_range& e) {
85431       {
85432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85433       };
85434     } catch (std::exception& e) {
85435       {
85436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85437       };
85438     } catch (...) {
85439       {
85440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85441       };
85442     }
85443   }
85444   jresult = result;
85445   return jresult;
85446 }
85447
85448
85449 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
85450   unsigned long jresult ;
85451   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85452   std::size_t result;
85453
85454   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85455   {
85456     try {
85457       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);
85458     } catch (std::out_of_range& e) {
85459       {
85460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85461       };
85462     } catch (std::exception& e) {
85463       {
85464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85465       };
85466     } catch (...) {
85467       {
85468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85469       };
85470     }
85471   }
85472   jresult = (unsigned long)result;
85473   return jresult;
85474 }
85475
85476
85477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
85478   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85479   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
85480
85481   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85482   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
85483   {
85484     try {
85485       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
85486     } catch (std::out_of_range& e) {
85487       {
85488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85489       };
85490     } catch (std::exception& e) {
85491       {
85492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85493       };
85494     } catch (...) {
85495       {
85496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85497       };
85498     }
85499   }
85500 }
85501
85502
85503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85504   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85505   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
85506
85507   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85508   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
85509   {
85510     try {
85511       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
85512     } catch (std::out_of_range& e) {
85513       {
85514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85515       };
85516     } catch (std::exception& e) {
85517       {
85518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85519       };
85520     } catch (...) {
85521       {
85522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85523       };
85524     }
85525   }
85526 }
85527
85528
85529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85530   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85531   Dali::Toolkit::StyleManager arg2 ;
85532   Dali::StyleChange::Type arg3 ;
85533   Dali::Toolkit::StyleManager *argp2 ;
85534
85535   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85536   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
85537   if (!argp2) {
85538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
85539     return ;
85540   }
85541   arg2 = *argp2;
85542   arg3 = (Dali::StyleChange::Type)jarg3;
85543   {
85544     try {
85545       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
85546     } catch (std::out_of_range& e) {
85547       {
85548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85549       };
85550     } catch (std::exception& e) {
85551       {
85552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85553       };
85554     } catch (...) {
85555       {
85556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85557       };
85558     }
85559   }
85560 }
85561
85562
85563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
85564   void * jresult ;
85565   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
85566
85567   {
85568     try {
85569       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
85570     } catch (std::out_of_range& e) {
85571       {
85572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85573       };
85574     } catch (std::exception& e) {
85575       {
85576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85577       };
85578     } catch (...) {
85579       {
85580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85581       };
85582     }
85583   }
85584   jresult = (void *)result;
85585   return jresult;
85586 }
85587
85588
85589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
85590   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85591
85592   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85593   {
85594     try {
85595       delete arg1;
85596     } catch (std::out_of_range& e) {
85597       {
85598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85599       };
85600     } catch (std::exception& e) {
85601       {
85602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85603       };
85604     } catch (...) {
85605       {
85606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85607       };
85608     }
85609   }
85610 }
85611
85612
85613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
85614   unsigned int jresult ;
85615   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85616   bool result;
85617
85618   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85619   {
85620     try {
85621       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
85622     } catch (std::out_of_range& e) {
85623       {
85624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85625       };
85626     } catch (std::exception& e) {
85627       {
85628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85629       };
85630     } catch (...) {
85631       {
85632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85633       };
85634     }
85635   }
85636   jresult = result;
85637   return jresult;
85638 }
85639
85640
85641 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
85642   unsigned long jresult ;
85643   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85644   std::size_t result;
85645
85646   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85647   {
85648     try {
85649       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
85650     } catch (std::out_of_range& e) {
85651       {
85652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85653       };
85654     } catch (std::exception& e) {
85655       {
85656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85657       };
85658     } catch (...) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85661       };
85662     }
85663   }
85664   jresult = (unsigned long)result;
85665   return jresult;
85666 }
85667
85668
85669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
85670   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85671   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
85672
85673   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85674   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
85675   {
85676     try {
85677       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
85678     } catch (std::out_of_range& e) {
85679       {
85680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85681       };
85682     } catch (std::exception& e) {
85683       {
85684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85685       };
85686     } catch (...) {
85687       {
85688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85689       };
85690     }
85691   }
85692 }
85693
85694
85695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
85696   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85697   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
85698
85699   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85700   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
85701   {
85702     try {
85703       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
85704     } catch (std::out_of_range& e) {
85705       {
85706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85707       };
85708     } catch (std::exception& e) {
85709       {
85710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85711       };
85712     } catch (...) {
85713       {
85714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85715       };
85716     }
85717   }
85718 }
85719
85720
85721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
85722   unsigned int jresult ;
85723   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85724   Dali::Toolkit::Button arg2 ;
85725   Dali::Toolkit::Button *argp2 ;
85726   bool result;
85727
85728   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85729   argp2 = (Dali::Toolkit::Button *)jarg2;
85730   if (!argp2) {
85731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
85732     return 0;
85733   }
85734   arg2 = *argp2;
85735   {
85736     try {
85737       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
85738     } catch (std::out_of_range& e) {
85739       {
85740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85741       };
85742     } catch (std::exception& e) {
85743       {
85744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85745       };
85746     } catch (...) {
85747       {
85748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85749       };
85750     }
85751   }
85752   jresult = result;
85753   return jresult;
85754 }
85755
85756
85757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
85758   void * jresult ;
85759   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
85760
85761   {
85762     try {
85763       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
85764     } catch (std::out_of_range& e) {
85765       {
85766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85767       };
85768     } catch (std::exception& e) {
85769       {
85770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85771       };
85772     } catch (...) {
85773       {
85774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85775       };
85776     }
85777   }
85778   jresult = (void *)result;
85779   return jresult;
85780 }
85781
85782
85783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
85784   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85785
85786   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85787   {
85788     try {
85789       delete arg1;
85790     } catch (std::out_of_range& e) {
85791       {
85792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85793       };
85794     } catch (std::exception& e) {
85795       {
85796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85797       };
85798     } catch (...) {
85799       {
85800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85801       };
85802     }
85803   }
85804 }
85805
85806
85807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
85808   unsigned int jresult ;
85809   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85810   bool result;
85811
85812   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85813   {
85814     try {
85815       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
85816     } catch (std::out_of_range& e) {
85817       {
85818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85819       };
85820     } catch (std::exception& e) {
85821       {
85822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85823       };
85824     } catch (...) {
85825       {
85826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85827       };
85828     }
85829   }
85830   jresult = result;
85831   return jresult;
85832 }
85833
85834
85835 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
85836   unsigned long jresult ;
85837   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85838   std::size_t result;
85839
85840   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85841   {
85842     try {
85843       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
85844     } catch (std::out_of_range& e) {
85845       {
85846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85847       };
85848     } catch (std::exception& e) {
85849       {
85850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (...) {
85853       {
85854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85855       };
85856     }
85857   }
85858   jresult = (unsigned long)result;
85859   return jresult;
85860 }
85861
85862
85863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
85864   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85865   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
85866
85867   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85868   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
85869   {
85870     try {
85871       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
85872     } catch (std::out_of_range& e) {
85873       {
85874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85875       };
85876     } catch (std::exception& e) {
85877       {
85878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85879       };
85880     } catch (...) {
85881       {
85882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85883       };
85884     }
85885   }
85886 }
85887
85888
85889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
85890   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85891   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
85892
85893   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85894   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
85895   {
85896     try {
85897       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
85898     } catch (std::out_of_range& e) {
85899       {
85900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85901       };
85902     } catch (std::exception& e) {
85903       {
85904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85905       };
85906     } catch (...) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85909       };
85910     }
85911   }
85912 }
85913
85914
85915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
85916   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85917   Dali::Toolkit::GaussianBlurView arg2 ;
85918   Dali::Toolkit::GaussianBlurView *argp2 ;
85919
85920   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85921   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
85922   if (!argp2) {
85923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
85924     return ;
85925   }
85926   arg2 = *argp2;
85927   {
85928     try {
85929       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
85930     } catch (std::out_of_range& e) {
85931       {
85932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85933       };
85934     } catch (std::exception& e) {
85935       {
85936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85937       };
85938     } catch (...) {
85939       {
85940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85941       };
85942     }
85943   }
85944 }
85945
85946
85947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
85948   void * jresult ;
85949   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
85950
85951   {
85952     try {
85953       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
85954     } catch (std::out_of_range& e) {
85955       {
85956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85957       };
85958     } catch (std::exception& e) {
85959       {
85960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85961       };
85962     } catch (...) {
85963       {
85964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85965       };
85966     }
85967   }
85968   jresult = (void *)result;
85969   return jresult;
85970 }
85971
85972
85973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
85974   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85975
85976   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85977   {
85978     try {
85979       delete arg1;
85980     } catch (std::out_of_range& e) {
85981       {
85982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85983       };
85984     } catch (std::exception& e) {
85985       {
85986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85987       };
85988     } catch (...) {
85989       {
85990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85991       };
85992     }
85993   }
85994 }
85995
85996
85997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
85998   unsigned int jresult ;
85999   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86000   bool result;
86001
86002   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86003   {
86004     try {
86005       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);
86006     } catch (std::out_of_range& e) {
86007       {
86008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86009       };
86010     } catch (std::exception& e) {
86011       {
86012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86013       };
86014     } catch (...) {
86015       {
86016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86017       };
86018     }
86019   }
86020   jresult = result;
86021   return jresult;
86022 }
86023
86024
86025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
86026   unsigned long jresult ;
86027   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86028   std::size_t result;
86029
86030   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86031   {
86032     try {
86033       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);
86034     } catch (std::out_of_range& e) {
86035       {
86036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (std::exception& e) {
86039       {
86040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86041       };
86042     } catch (...) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86045       };
86046     }
86047   }
86048   jresult = (unsigned long)result;
86049   return jresult;
86050 }
86051
86052
86053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
86054   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86055   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
86056
86057   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86058   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
86059   {
86060     try {
86061       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
86062     } catch (std::out_of_range& e) {
86063       {
86064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86065       };
86066     } catch (std::exception& e) {
86067       {
86068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86069       };
86070     } catch (...) {
86071       {
86072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86073       };
86074     }
86075   }
86076 }
86077
86078
86079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
86080   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86081   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
86082
86083   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86084   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
86085   {
86086     try {
86087       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
86088     } catch (std::out_of_range& e) {
86089       {
86090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86091       };
86092     } catch (std::exception& e) {
86093       {
86094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86095       };
86096     } catch (...) {
86097       {
86098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86099       };
86100     }
86101   }
86102 }
86103
86104
86105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
86106   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86107   Dali::Toolkit::PageTurnView arg2 ;
86108   unsigned int arg3 ;
86109   bool arg4 ;
86110   Dali::Toolkit::PageTurnView *argp2 ;
86111
86112   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86113   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
86114   if (!argp2) {
86115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
86116     return ;
86117   }
86118   arg2 = *argp2;
86119   arg3 = (unsigned int)jarg3;
86120   arg4 = jarg4 ? true : false;
86121   {
86122     try {
86123       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
86124     } catch (std::out_of_range& e) {
86125       {
86126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86127       };
86128     } catch (std::exception& e) {
86129       {
86130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86131       };
86132     } catch (...) {
86133       {
86134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86135       };
86136     }
86137   }
86138 }
86139
86140
86141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
86142   void * jresult ;
86143   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
86144
86145   {
86146     try {
86147       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
86148     } catch (std::out_of_range& e) {
86149       {
86150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86151       };
86152     } catch (std::exception& e) {
86153       {
86154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86155       };
86156     } catch (...) {
86157       {
86158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86159       };
86160     }
86161   }
86162   jresult = (void *)result;
86163   return jresult;
86164 }
86165
86166
86167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
86168   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86169
86170   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86171   {
86172     try {
86173       delete arg1;
86174     } catch (std::out_of_range& e) {
86175       {
86176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86177       };
86178     } catch (std::exception& e) {
86179       {
86180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86181       };
86182     } catch (...) {
86183       {
86184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86185       };
86186     }
86187   }
86188 }
86189
86190
86191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
86192   unsigned int jresult ;
86193   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86194   bool result;
86195
86196   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86197   {
86198     try {
86199       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
86200     } catch (std::out_of_range& e) {
86201       {
86202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86203       };
86204     } catch (std::exception& e) {
86205       {
86206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86207       };
86208     } catch (...) {
86209       {
86210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86211       };
86212     }
86213   }
86214   jresult = result;
86215   return jresult;
86216 }
86217
86218
86219 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
86220   unsigned long jresult ;
86221   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86222   std::size_t result;
86223
86224   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86225   {
86226     try {
86227       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
86228     } catch (std::out_of_range& e) {
86229       {
86230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86231       };
86232     } catch (std::exception& e) {
86233       {
86234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86235       };
86236     } catch (...) {
86237       {
86238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86239       };
86240     }
86241   }
86242   jresult = (unsigned long)result;
86243   return jresult;
86244 }
86245
86246
86247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
86248   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86249   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
86250
86251   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86252   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
86253   {
86254     try {
86255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
86256     } catch (std::out_of_range& e) {
86257       {
86258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86259       };
86260     } catch (std::exception& e) {
86261       {
86262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86263       };
86264     } catch (...) {
86265       {
86266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86267       };
86268     }
86269   }
86270 }
86271
86272
86273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
86274   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86275   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
86276
86277   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86278   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
86279   {
86280     try {
86281       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
86282     } catch (std::out_of_range& e) {
86283       {
86284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86285       };
86286     } catch (std::exception& e) {
86287       {
86288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86289       };
86290     } catch (...) {
86291       {
86292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86293       };
86294     }
86295   }
86296 }
86297
86298
86299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
86300   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86301   Dali::Toolkit::PageTurnView arg2 ;
86302   Dali::Toolkit::PageTurnView *argp2 ;
86303
86304   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86305   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
86306   if (!argp2) {
86307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
86308     return ;
86309   }
86310   arg2 = *argp2;
86311   {
86312     try {
86313       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
86314     } catch (std::out_of_range& e) {
86315       {
86316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86317       };
86318     } catch (std::exception& e) {
86319       {
86320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86321       };
86322     } catch (...) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86325       };
86326     }
86327   }
86328 }
86329
86330
86331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
86332   void * jresult ;
86333   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
86334
86335   {
86336     try {
86337       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
86338     } catch (std::out_of_range& e) {
86339       {
86340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86341       };
86342     } catch (std::exception& e) {
86343       {
86344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86345       };
86346     } catch (...) {
86347       {
86348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86349       };
86350     }
86351   }
86352   jresult = (void *)result;
86353   return jresult;
86354 }
86355
86356
86357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
86358   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86359
86360   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86361   {
86362     try {
86363       delete arg1;
86364     } catch (std::out_of_range& e) {
86365       {
86366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86367       };
86368     } catch (std::exception& e) {
86369       {
86370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86371       };
86372     } catch (...) {
86373       {
86374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86375       };
86376     }
86377   }
86378 }
86379
86380
86381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
86382   unsigned int jresult ;
86383   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86384   bool result;
86385
86386   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86387   {
86388     try {
86389       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);
86390     } catch (std::out_of_range& e) {
86391       {
86392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86393       };
86394     } catch (std::exception& e) {
86395       {
86396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86397       };
86398     } catch (...) {
86399       {
86400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86401       };
86402     }
86403   }
86404   jresult = result;
86405   return jresult;
86406 }
86407
86408
86409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
86410   unsigned long jresult ;
86411   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86412   std::size_t result;
86413
86414   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86415   {
86416     try {
86417       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);
86418     } catch (std::out_of_range& e) {
86419       {
86420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86421       };
86422     } catch (std::exception& e) {
86423       {
86424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (...) {
86427       {
86428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86429       };
86430     }
86431   }
86432   jresult = (unsigned long)result;
86433   return jresult;
86434 }
86435
86436
86437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
86438   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86439   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
86440
86441   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86442   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
86443   {
86444     try {
86445       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
86446     } catch (std::out_of_range& e) {
86447       {
86448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86449       };
86450     } catch (std::exception& e) {
86451       {
86452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86453       };
86454     } catch (...) {
86455       {
86456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86457       };
86458     }
86459   }
86460 }
86461
86462
86463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
86464   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86465   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
86466
86467   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86468   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
86469   {
86470     try {
86471       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
86472     } catch (std::out_of_range& e) {
86473       {
86474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86475       };
86476     } catch (std::exception& e) {
86477       {
86478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86479       };
86480     } catch (...) {
86481       {
86482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86483       };
86484     }
86485   }
86486 }
86487
86488
86489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
86490   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86491   Dali::Toolkit::ProgressBar arg2 ;
86492   float arg3 ;
86493   float arg4 ;
86494   Dali::Toolkit::ProgressBar *argp2 ;
86495
86496   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86497   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
86498   if (!argp2) {
86499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
86500     return ;
86501   }
86502   arg2 = *argp2;
86503   arg3 = (float)jarg3;
86504   arg4 = (float)jarg4;
86505   {
86506     try {
86507       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
86508     } catch (std::out_of_range& e) {
86509       {
86510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86511       };
86512     } catch (std::exception& e) {
86513       {
86514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86515       };
86516     } catch (...) {
86517       {
86518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86519       };
86520     }
86521   }
86522 }
86523
86524
86525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
86526   void * jresult ;
86527   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
86528
86529   {
86530     try {
86531       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
86532     } catch (std::out_of_range& e) {
86533       {
86534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86535       };
86536     } catch (std::exception& e) {
86537       {
86538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86539       };
86540     } catch (...) {
86541       {
86542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86543       };
86544     }
86545   }
86546   jresult = (void *)result;
86547   return jresult;
86548 }
86549
86550
86551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
86552   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86553
86554   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86555   {
86556     try {
86557       delete arg1;
86558     } catch (std::out_of_range& e) {
86559       {
86560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86561       };
86562     } catch (std::exception& e) {
86563       {
86564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86565       };
86566     } catch (...) {
86567       {
86568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86569       };
86570     }
86571   }
86572 }
86573
86574
86575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
86576   unsigned int jresult ;
86577   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86578   bool result;
86579
86580   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86581   {
86582     try {
86583       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);
86584     } catch (std::out_of_range& e) {
86585       {
86586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86587       };
86588     } catch (std::exception& e) {
86589       {
86590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86591       };
86592     } catch (...) {
86593       {
86594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86595       };
86596     }
86597   }
86598   jresult = result;
86599   return jresult;
86600 }
86601
86602
86603 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
86604   unsigned long jresult ;
86605   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86606   std::size_t result;
86607
86608   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86609   {
86610     try {
86611       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);
86612     } catch (std::out_of_range& e) {
86613       {
86614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86615       };
86616     } catch (std::exception& e) {
86617       {
86618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86619       };
86620     } catch (...) {
86621       {
86622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86623       };
86624     }
86625   }
86626   jresult = (unsigned long)result;
86627   return jresult;
86628 }
86629
86630
86631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
86632   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86633   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
86634
86635   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86636   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
86637   {
86638     try {
86639       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
86640     } catch (std::out_of_range& e) {
86641       {
86642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86643       };
86644     } catch (std::exception& e) {
86645       {
86646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86647       };
86648     } catch (...) {
86649       {
86650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86651       };
86652     }
86653   }
86654 }
86655
86656
86657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
86658   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86659   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
86660
86661   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86662   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
86663   {
86664     try {
86665       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
86666     } catch (std::out_of_range& e) {
86667       {
86668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86669       };
86670     } catch (std::exception& e) {
86671       {
86672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86673       };
86674     } catch (...) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86677       };
86678     }
86679   }
86680 }
86681
86682
86683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
86684   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86685   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
86686
86687   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86688   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
86689   if (!arg2) {
86690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
86691     return ;
86692   }
86693   {
86694     try {
86695       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
86696     } catch (std::out_of_range& e) {
86697       {
86698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86699       };
86700     } catch (std::exception& e) {
86701       {
86702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86703       };
86704     } catch (...) {
86705       {
86706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86707       };
86708     }
86709   }
86710 }
86711
86712
86713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
86714   void * jresult ;
86715   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
86716
86717   {
86718     try {
86719       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
86720     } catch (std::out_of_range& e) {
86721       {
86722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86723       };
86724     } catch (std::exception& e) {
86725       {
86726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (...) {
86729       {
86730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86731       };
86732     }
86733   }
86734   jresult = (void *)result;
86735   return jresult;
86736 }
86737
86738
86739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
86740   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86741
86742   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86743   {
86744     try {
86745       delete arg1;
86746     } catch (std::out_of_range& e) {
86747       {
86748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86749       };
86750     } catch (std::exception& e) {
86751       {
86752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86753       };
86754     } catch (...) {
86755       {
86756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86757       };
86758     }
86759   }
86760 }
86761
86762
86763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
86764   unsigned int jresult ;
86765   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86766   bool result;
86767
86768   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86769   {
86770     try {
86771       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
86772     } catch (std::out_of_range& e) {
86773       {
86774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (std::exception& e) {
86777       {
86778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86779       };
86780     } catch (...) {
86781       {
86782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86783       };
86784     }
86785   }
86786   jresult = result;
86787   return jresult;
86788 }
86789
86790
86791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
86792   unsigned long jresult ;
86793   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86794   std::size_t result;
86795
86796   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86797   {
86798     try {
86799       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
86800     } catch (std::out_of_range& e) {
86801       {
86802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86803       };
86804     } catch (std::exception& e) {
86805       {
86806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86807       };
86808     } catch (...) {
86809       {
86810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86811       };
86812     }
86813   }
86814   jresult = (unsigned long)result;
86815   return jresult;
86816 }
86817
86818
86819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
86820   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86821   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
86822
86823   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86824   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
86825   {
86826     try {
86827       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
86828     } catch (std::out_of_range& e) {
86829       {
86830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86831       };
86832     } catch (std::exception& e) {
86833       {
86834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86835       };
86836     } catch (...) {
86837       {
86838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86839       };
86840     }
86841   }
86842 }
86843
86844
86845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
86846   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86847   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
86848
86849   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86850   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
86851   {
86852     try {
86853       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
86854     } catch (std::out_of_range& e) {
86855       {
86856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86857       };
86858     } catch (std::exception& e) {
86859       {
86860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86865       };
86866     }
86867   }
86868 }
86869
86870
86871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
86872   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86873   Dali::Vector2 *arg2 = 0 ;
86874
86875   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86876   arg2 = (Dali::Vector2 *)jarg2;
86877   if (!arg2) {
86878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
86879     return ;
86880   }
86881   {
86882     try {
86883       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
86884     } catch (std::out_of_range& e) {
86885       {
86886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86887       };
86888     } catch (std::exception& e) {
86889       {
86890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86891       };
86892     } catch (...) {
86893       {
86894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86895       };
86896     }
86897   }
86898 }
86899
86900
86901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
86902   void * jresult ;
86903   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
86904
86905   {
86906     try {
86907       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
86908     } catch (std::out_of_range& e) {
86909       {
86910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86911       };
86912     } catch (std::exception& e) {
86913       {
86914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86915       };
86916     } catch (...) {
86917       {
86918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86919       };
86920     }
86921   }
86922   jresult = (void *)result;
86923   return jresult;
86924 }
86925
86926
86927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
86928   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86929
86930   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86931   {
86932     try {
86933       delete arg1;
86934     } catch (std::out_of_range& e) {
86935       {
86936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86937       };
86938     } catch (std::exception& e) {
86939       {
86940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86941       };
86942     } catch (...) {
86943       {
86944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86945       };
86946     }
86947   }
86948 }
86949
86950
86951
86952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
86953   unsigned int jresult ;
86954   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
86955   bool result;
86956
86957   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
86958   {
86959     try {
86960       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);
86961     } catch (std::out_of_range& e) {
86962       {
86963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86964       };
86965     } catch (std::exception& e) {
86966       {
86967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86968       };
86969     } catch (...) {
86970       {
86971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86972       };
86973     }
86974   }
86975   jresult = result;
86976   return jresult;
86977 }
86978
86979
86980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
86981   unsigned long jresult ;
86982   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
86983   std::size_t result;
86984
86985   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
86986   {
86987     try {
86988       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);
86989     } catch (std::out_of_range& e) {
86990       {
86991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86992       };
86993     } catch (std::exception& e) {
86994       {
86995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86996       };
86997     } catch (...) {
86998       {
86999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87000       };
87001     }
87002   }
87003   jresult = (unsigned long)result;
87004   return jresult;
87005 }
87006
87007
87008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
87009   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87010   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
87011
87012   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87013   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
87014   {
87015     try {
87016       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
87017     } catch (std::out_of_range& e) {
87018       {
87019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87020       };
87021     } catch (std::exception& e) {
87022       {
87023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87024       };
87025     } catch (...) {
87026       {
87027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87028       };
87029     }
87030   }
87031 }
87032
87033
87034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
87035   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87036   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
87037
87038   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87039   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
87040   {
87041     try {
87042       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
87043     } catch (std::out_of_range& e) {
87044       {
87045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87046       };
87047     } catch (std::exception& e) {
87048       {
87049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87050       };
87051     } catch (...) {
87052       {
87053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87054       };
87055     }
87056   }
87057 }
87058
87059
87060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
87061   unsigned int jresult ;
87062   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87063   Dali::Toolkit::Control arg2 ;
87064   Dali::KeyEvent *arg3 = 0 ;
87065   Dali::Toolkit::Control *argp2 ;
87066   bool result;
87067
87068   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87069   argp2 = (Dali::Toolkit::Control *)jarg2;
87070   if (!argp2) {
87071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87072     return 0;
87073   }
87074   arg2 = *argp2;
87075   arg3 = (Dali::KeyEvent *)jarg3;
87076   if (!arg3) {
87077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
87078     return 0;
87079   }
87080   {
87081     try {
87082       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);
87083     } catch (std::out_of_range& e) {
87084       {
87085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87086       };
87087     } catch (std::exception& e) {
87088       {
87089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87090       };
87091     } catch (...) {
87092       {
87093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87094       };
87095     }
87096   }
87097   jresult = result;
87098   return jresult;
87099 }
87100
87101
87102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
87103   void * jresult ;
87104   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
87105
87106   {
87107     try {
87108       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
87109     } catch (std::out_of_range& e) {
87110       {
87111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87112       };
87113     } catch (std::exception& e) {
87114       {
87115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87116       };
87117     } catch (...) {
87118       {
87119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87120       };
87121     }
87122   }
87123   jresult = (void *)result;
87124   return jresult;
87125 }
87126
87127
87128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
87129   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87130
87131   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87132   {
87133     try {
87134       delete arg1;
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87142       };
87143     } catch (...) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87146       };
87147     }
87148   }
87149 }
87150
87151
87152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
87153   unsigned int jresult ;
87154   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87155   bool result;
87156
87157   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87158   {
87159     try {
87160       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87161     } catch (std::out_of_range& e) {
87162       {
87163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87164       };
87165     } catch (std::exception& e) {
87166       {
87167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87168       };
87169     } catch (...) {
87170       {
87171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87172       };
87173     }
87174   }
87175   jresult = result;
87176   return jresult;
87177 }
87178
87179
87180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
87181   unsigned long jresult ;
87182   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87183   std::size_t result;
87184
87185   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87186   {
87187     try {
87188       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87189     } catch (std::out_of_range& e) {
87190       {
87191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87192       };
87193     } catch (std::exception& e) {
87194       {
87195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87196       };
87197     } catch (...) {
87198       {
87199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87200       };
87201     }
87202   }
87203   jresult = (unsigned long)result;
87204   return jresult;
87205 }
87206
87207
87208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
87209   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87210   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87211
87212   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87213   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87214   {
87215     try {
87216       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
87217     } catch (std::out_of_range& e) {
87218       {
87219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87220       };
87221     } catch (std::exception& e) {
87222       {
87223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87224       };
87225     } catch (...) {
87226       {
87227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87228       };
87229     }
87230   }
87231 }
87232
87233
87234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
87235   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87236   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87237
87238   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87239   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87240   {
87241     try {
87242       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
87243     } catch (std::out_of_range& e) {
87244       {
87245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87246       };
87247     } catch (std::exception& e) {
87248       {
87249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87250       };
87251     } catch (...) {
87252       {
87253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87254       };
87255     }
87256   }
87257 }
87258
87259
87260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
87261   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87262   Dali::Toolkit::Control arg2 ;
87263   Dali::Toolkit::Control *argp2 ;
87264
87265   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87266   argp2 = (Dali::Toolkit::Control *)jarg2;
87267   if (!argp2) {
87268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87269     return ;
87270   }
87271   arg2 = *argp2;
87272   {
87273     try {
87274       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87275     } catch (std::out_of_range& e) {
87276       {
87277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87278       };
87279     } catch (std::exception& e) {
87280       {
87281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87282       };
87283     } catch (...) {
87284       {
87285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87286       };
87287     }
87288   }
87289 }
87290
87291
87292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
87293   void * jresult ;
87294   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87295
87296   {
87297     try {
87298       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87299     } catch (std::out_of_range& e) {
87300       {
87301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87302       };
87303     } catch (std::exception& e) {
87304       {
87305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87306       };
87307     } catch (...) {
87308       {
87309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87310       };
87311     }
87312   }
87313   jresult = (void *)result;
87314   return jresult;
87315 }
87316
87317
87318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
87319   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87320
87321   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87322   {
87323     try {
87324       delete arg1;
87325     } catch (std::out_of_range& e) {
87326       {
87327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87328       };
87329     } catch (std::exception& e) {
87330       {
87331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87332       };
87333     } catch (...) {
87334       {
87335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87336       };
87337     }
87338   }
87339 }
87340
87341
87342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
87343   unsigned int jresult ;
87344   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87345   bool result;
87346
87347   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87348   {
87349     try {
87350       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
87351     } catch (std::out_of_range& e) {
87352       {
87353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87354       };
87355     } catch (std::exception& e) {
87356       {
87357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87358       };
87359     } catch (...) {
87360       {
87361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87362       };
87363     }
87364   }
87365   jresult = result;
87366   return jresult;
87367 }
87368
87369
87370 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
87371   unsigned long jresult ;
87372   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87373   std::size_t result;
87374
87375   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87376   {
87377     try {
87378       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
87379     } catch (std::out_of_range& e) {
87380       {
87381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87382       };
87383     } catch (std::exception& e) {
87384       {
87385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87386       };
87387     } catch (...) {
87388       {
87389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87390       };
87391     }
87392   }
87393   jresult = (unsigned long)result;
87394   return jresult;
87395 }
87396
87397
87398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
87399   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87400   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
87401
87402   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87403   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
87404   {
87405     try {
87406       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
87407     } catch (std::out_of_range& e) {
87408       {
87409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87410       };
87411     } catch (std::exception& e) {
87412       {
87413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87414       };
87415     } catch (...) {
87416       {
87417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87418       };
87419     }
87420   }
87421 }
87422
87423
87424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
87425   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87426   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
87427
87428   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87429   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
87430   {
87431     try {
87432       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
87433     } catch (std::out_of_range& e) {
87434       {
87435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87436       };
87437     } catch (std::exception& e) {
87438       {
87439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87440       };
87441     } catch (...) {
87442       {
87443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87444       };
87445     }
87446   }
87447 }
87448
87449
87450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
87451   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87452   Dali::Toolkit::VideoView *arg2 = 0 ;
87453
87454   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87455   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87456   if (!arg2) {
87457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
87458     return ;
87459   }
87460   {
87461     try {
87462       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
87463     } catch (std::out_of_range& e) {
87464       {
87465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87466       };
87467     } catch (std::exception& e) {
87468       {
87469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87470       };
87471     } catch (...) {
87472       {
87473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87474       };
87475     }
87476   }
87477 }
87478
87479
87480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
87481   void * jresult ;
87482   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
87483
87484   {
87485     try {
87486       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
87487     } catch (std::out_of_range& e) {
87488       {
87489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87490       };
87491     } catch (std::exception& e) {
87492       {
87493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87494       };
87495     } catch (...) {
87496       {
87497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87498       };
87499     }
87500   }
87501   jresult = (void *)result;
87502   return jresult;
87503 }
87504
87505
87506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
87507   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87508
87509   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87510   {
87511     try {
87512       delete arg1;
87513     } catch (std::out_of_range& e) {
87514       {
87515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87516       };
87517     } catch (std::exception& e) {
87518       {
87519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87520       };
87521     } catch (...) {
87522       {
87523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87524       };
87525     }
87526   }
87527 }
87528
87529
87530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
87531   unsigned int jresult ;
87532   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87533   bool result;
87534
87535   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87536   {
87537     try {
87538       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
87539     } catch (std::out_of_range& e) {
87540       {
87541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87542       };
87543     } catch (std::exception& e) {
87544       {
87545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87546       };
87547     } catch (...) {
87548       {
87549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87550       };
87551     }
87552   }
87553   jresult = result;
87554   return jresult;
87555 }
87556
87557
87558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
87559   unsigned long jresult ;
87560   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87561   std::size_t result;
87562
87563   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87564   {
87565     try {
87566       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
87567     } catch (std::out_of_range& e) {
87568       {
87569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87570       };
87571     } catch (std::exception& e) {
87572       {
87573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87574       };
87575     } catch (...) {
87576       {
87577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87578       };
87579     }
87580   }
87581   jresult = (unsigned long)result;
87582   return jresult;
87583 }
87584
87585
87586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
87587   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87588   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
87589
87590   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87591   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
87592   {
87593     try {
87594       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
87595     } catch (std::out_of_range& e) {
87596       {
87597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87598       };
87599     } catch (std::exception& e) {
87600       {
87601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87602       };
87603     } catch (...) {
87604       {
87605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87606       };
87607     }
87608   }
87609 }
87610
87611
87612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
87613   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87614   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
87615
87616   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87617   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
87618   {
87619     try {
87620       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
87621     } catch (std::out_of_range& e) {
87622       {
87623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87624       };
87625     } catch (std::exception& e) {
87626       {
87627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87628       };
87629     } catch (...) {
87630       {
87631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87632       };
87633     }
87634   }
87635 }
87636
87637
87638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
87639   unsigned int jresult ;
87640   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87641   Dali::Toolkit::Slider arg2 ;
87642   float arg3 ;
87643   Dali::Toolkit::Slider *argp2 ;
87644   bool result;
87645
87646   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87647   argp2 = (Dali::Toolkit::Slider *)jarg2;
87648   if (!argp2) {
87649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
87650     return 0;
87651   }
87652   arg2 = *argp2;
87653   arg3 = (float)jarg3;
87654   {
87655     try {
87656       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
87657     } catch (std::out_of_range& e) {
87658       {
87659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87660       };
87661     } catch (std::exception& e) {
87662       {
87663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87664       };
87665     } catch (...) {
87666       {
87667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87668       };
87669     }
87670   }
87671   jresult = result;
87672   return jresult;
87673 }
87674
87675
87676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
87677   void * jresult ;
87678   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
87679
87680   {
87681     try {
87682       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
87683     } catch (std::out_of_range& e) {
87684       {
87685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87686       };
87687     } catch (std::exception& e) {
87688       {
87689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87690       };
87691     } catch (...) {
87692       {
87693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87694       };
87695     }
87696   }
87697   jresult = (void *)result;
87698   return jresult;
87699 }
87700
87701
87702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
87703   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87704
87705   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87706   {
87707     try {
87708       delete arg1;
87709     } catch (std::out_of_range& e) {
87710       {
87711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87712       };
87713     } catch (std::exception& e) {
87714       {
87715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87716       };
87717     } catch (...) {
87718       {
87719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87720       };
87721     }
87722   }
87723 }
87724
87725
87726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
87727   unsigned int jresult ;
87728   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87729   bool result;
87730
87731   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87732   {
87733     try {
87734       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
87735     } catch (std::out_of_range& e) {
87736       {
87737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87738       };
87739     } catch (std::exception& e) {
87740       {
87741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87742       };
87743     } catch (...) {
87744       {
87745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87746       };
87747     }
87748   }
87749   jresult = result;
87750   return jresult;
87751 }
87752
87753
87754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
87755   unsigned long jresult ;
87756   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87757   std::size_t result;
87758
87759   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87760   {
87761     try {
87762       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
87763     } catch (std::out_of_range& e) {
87764       {
87765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87766       };
87767     } catch (std::exception& e) {
87768       {
87769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87770       };
87771     } catch (...) {
87772       {
87773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87774       };
87775     }
87776   }
87777   jresult = (unsigned long)result;
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
87783   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87784   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
87785
87786   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87787   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
87788   {
87789     try {
87790       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
87791     } catch (std::out_of_range& e) {
87792       {
87793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87794       };
87795     } catch (std::exception& e) {
87796       {
87797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87798       };
87799     } catch (...) {
87800       {
87801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87802       };
87803     }
87804   }
87805 }
87806
87807
87808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
87809   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87810   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
87811
87812   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87813   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
87814   {
87815     try {
87816       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
87817     } catch (std::out_of_range& e) {
87818       {
87819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87820       };
87821     } catch (std::exception& e) {
87822       {
87823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87824       };
87825     } catch (...) {
87826       {
87827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87828       };
87829     }
87830   }
87831 }
87832
87833
87834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
87835   unsigned int jresult ;
87836   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87837   Dali::Toolkit::Slider arg2 ;
87838   int arg3 ;
87839   Dali::Toolkit::Slider *argp2 ;
87840   bool result;
87841
87842   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87843   argp2 = (Dali::Toolkit::Slider *)jarg2;
87844   if (!argp2) {
87845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
87846     return 0;
87847   }
87848   arg2 = *argp2;
87849   arg3 = (int)jarg3;
87850   {
87851     try {
87852       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
87853     } catch (std::out_of_range& e) {
87854       {
87855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87856       };
87857     } catch (std::exception& e) {
87858       {
87859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87860       };
87861     } catch (...) {
87862       {
87863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87864       };
87865     }
87866   }
87867   jresult = result;
87868   return jresult;
87869 }
87870
87871
87872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
87873   void * jresult ;
87874   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
87875
87876   {
87877     try {
87878       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
87879     } catch (std::out_of_range& e) {
87880       {
87881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87882       };
87883     } catch (std::exception& e) {
87884       {
87885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87886       };
87887     } catch (...) {
87888       {
87889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87890       };
87891     }
87892   }
87893   jresult = (void *)result;
87894   return jresult;
87895 }
87896
87897
87898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
87899   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87900
87901   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87902   {
87903     try {
87904       delete arg1;
87905     } catch (std::out_of_range& e) {
87906       {
87907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87908       };
87909     } catch (std::exception& e) {
87910       {
87911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87912       };
87913     } catch (...) {
87914       {
87915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87916       };
87917     }
87918   }
87919 }
87920
87921
87922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
87923   void * jresult ;
87924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
87925
87926   {
87927     try {
87928       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
87929     } catch (std::out_of_range& e) {
87930       {
87931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87932       };
87933     } catch (std::exception& e) {
87934       {
87935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87936       };
87937     } catch (...) {
87938       {
87939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87940       };
87941     }
87942   }
87943   jresult = (void *)result;
87944   return jresult;
87945 }
87946
87947
87948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
87949   void * jresult ;
87950   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
87951   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
87952
87953   arg1 = (Dali::Toolkit::Ruler *)jarg1;
87954   {
87955     try {
87956       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
87957     } catch (std::out_of_range& e) {
87958       {
87959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87960       };
87961     } catch (std::exception& e) {
87962       {
87963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87964       };
87965     } catch (...) {
87966       {
87967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87968       };
87969     }
87970   }
87971   jresult = (void *)result;
87972   return jresult;
87973 }
87974
87975
87976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
87977   void * jresult ;
87978   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
87979   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
87980
87981   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87982   if (!arg1) {
87983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
87984     return 0;
87985   }
87986   {
87987     try {
87988       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
87989     } catch (std::out_of_range& e) {
87990       {
87991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87992       };
87993     } catch (std::exception& e) {
87994       {
87995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87996       };
87997     } catch (...) {
87998       {
87999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88000       };
88001     }
88002   }
88003   jresult = (void *)result;
88004   return jresult;
88005 }
88006
88007
88008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
88009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88010
88011   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88012   {
88013     try {
88014       delete arg1;
88015     } catch (std::out_of_range& e) {
88016       {
88017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88018       };
88019     } catch (std::exception& e) {
88020       {
88021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88022       };
88023     } catch (...) {
88024       {
88025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88026       };
88027     }
88028   }
88029 }
88030
88031
88032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
88033   void * jresult ;
88034   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88035   Dali::Toolkit::Ruler *result = 0 ;
88036
88037   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88038   {
88039     try {
88040       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
88041     } catch (std::out_of_range& e) {
88042       {
88043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88044       };
88045     } catch (std::exception& e) {
88046       {
88047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88048       };
88049     } catch (...) {
88050       {
88051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88052       };
88053     }
88054   }
88055   jresult = (void *)result;
88056   return jresult;
88057 }
88058
88059
88060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
88061   void * jresult ;
88062   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88063   Dali::Toolkit::Ruler *result = 0 ;
88064
88065   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88066   {
88067     try {
88068       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
88069     } catch (std::out_of_range& e) {
88070       {
88071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88072       };
88073     } catch (std::exception& e) {
88074       {
88075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88080       };
88081     }
88082   }
88083   jresult = (void *)result;
88084   return jresult;
88085 }
88086
88087
88088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
88089   void * jresult ;
88090   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88091   Dali::Toolkit::Ruler *result = 0 ;
88092
88093   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88094   {
88095     try {
88096       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
88097     } catch (std::out_of_range& e) {
88098       {
88099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88100       };
88101     } catch (std::exception& e) {
88102       {
88103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88104       };
88105     } catch (...) {
88106       {
88107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88108       };
88109     }
88110   }
88111   jresult = (void *)result;
88112   return jresult;
88113 }
88114
88115
88116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
88117   void * jresult ;
88118   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88119   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
88120   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88121
88122   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88123   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
88124   if (!arg2) {
88125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
88126     return 0;
88127   }
88128   {
88129     try {
88130       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
88131     } catch (std::out_of_range& e) {
88132       {
88133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88134       };
88135     } catch (std::exception& e) {
88136       {
88137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88138       };
88139     } catch (...) {
88140       {
88141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88142       };
88143     }
88144   }
88145   jresult = (void *)result;
88146   return jresult;
88147 }
88148
88149
88150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
88151   void * jresult ;
88152   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88153   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
88154   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88155
88156   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88157   arg2 = (Dali::Toolkit::Ruler *)jarg2;
88158   {
88159     try {
88160       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
88161     } catch (std::out_of_range& e) {
88162       {
88163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88164       };
88165     } catch (std::exception& e) {
88166       {
88167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88168       };
88169     } catch (...) {
88170       {
88171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88172       };
88173     }
88174   }
88175   jresult = (void *)result;
88176   return jresult;
88177 }
88178
88179
88180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
88181   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88182
88183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88184   {
88185     try {
88186       (arg1)->Reset();
88187     } catch (std::out_of_range& e) {
88188       {
88189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88190       };
88191     } catch (std::exception& e) {
88192       {
88193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88194       };
88195     } catch (...) {
88196       {
88197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88198       };
88199     }
88200   }
88201 }
88202
88203
88204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
88205   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88206   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
88207
88208   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88209   arg2 = (Dali::Toolkit::Ruler *)jarg2;
88210   {
88211     try {
88212       (arg1)->Reset(arg2);
88213     } catch (std::out_of_range& e) {
88214       {
88215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88216       };
88217     } catch (std::exception& e) {
88218       {
88219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88220       };
88221     } catch (...) {
88222       {
88223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88224       };
88225     }
88226   }
88227 }
88228
88229
88230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
88231   void * jresult ;
88232   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88233   Dali::Toolkit::Ruler *result = 0 ;
88234
88235   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88236   {
88237     try {
88238       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
88239     } catch (std::out_of_range& e) {
88240       {
88241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88242       };
88243     } catch (std::exception& e) {
88244       {
88245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88246       };
88247     } catch (...) {
88248       {
88249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88250       };
88251     }
88252   }
88253   jresult = (void *)result;
88254   return jresult;
88255 }
88256
88257
88258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
88259   float jresult ;
88260   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88261   float arg2 ;
88262   float arg3 ;
88263   float result;
88264
88265   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88266   arg2 = (float)jarg2;
88267   arg3 = (float)jarg3;
88268   {
88269     try {
88270       result = (float)(*arg1)->Snap(arg2,arg3);
88271     } catch (std::out_of_range& e) {
88272       {
88273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88274       };
88275     } catch (std::exception& e) {
88276       {
88277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88278       };
88279     } catch (...) {
88280       {
88281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88282       };
88283     }
88284   }
88285   jresult = result;
88286   return jresult;
88287 }
88288
88289
88290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
88291   float jresult ;
88292   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88293   float arg2 ;
88294   float result;
88295
88296   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88297   arg2 = (float)jarg2;
88298   {
88299     try {
88300       result = (float)(*arg1)->Snap(arg2);
88301     } catch (std::out_of_range& e) {
88302       {
88303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88304       };
88305     } catch (std::exception& e) {
88306       {
88307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88308       };
88309     } catch (...) {
88310       {
88311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88312       };
88313     }
88314   }
88315   jresult = result;
88316   return jresult;
88317 }
88318
88319
88320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
88321   float jresult ;
88322   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88323   unsigned int arg2 ;
88324   unsigned int *arg3 = 0 ;
88325   bool arg4 ;
88326   float result;
88327
88328   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88329   arg2 = (unsigned int)jarg2;
88330   arg3 = (unsigned int *)jarg3;
88331   arg4 = jarg4 ? true : false;
88332   {
88333     try {
88334       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
88335     } catch (std::out_of_range& e) {
88336       {
88337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88338       };
88339     } catch (std::exception& e) {
88340       {
88341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88342       };
88343     } catch (...) {
88344       {
88345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88346       };
88347     }
88348   }
88349   jresult = result;
88350   return jresult;
88351 }
88352
88353
88354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
88355   unsigned int jresult ;
88356   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88357   float arg2 ;
88358   bool arg3 ;
88359   unsigned int result;
88360
88361   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88362   arg2 = (float)jarg2;
88363   arg3 = jarg3 ? true : false;
88364   {
88365     try {
88366       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
88367     } catch (std::out_of_range& e) {
88368       {
88369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88370       };
88371     } catch (std::exception& e) {
88372       {
88373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88374       };
88375     } catch (...) {
88376       {
88377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88378       };
88379     }
88380   }
88381   jresult = result;
88382   return jresult;
88383 }
88384
88385
88386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
88387   unsigned int jresult ;
88388   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88389   unsigned int result;
88390
88391   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88392   {
88393     try {
88394       result = (unsigned int)(*arg1)->GetTotalPages();
88395     } catch (std::out_of_range& e) {
88396       {
88397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88398       };
88399     } catch (std::exception& e) {
88400       {
88401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88402       };
88403     } catch (...) {
88404       {
88405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88406       };
88407     }
88408   }
88409   jresult = result;
88410   return jresult;
88411 }
88412
88413
88414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
88415   int jresult ;
88416   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88417   Dali::Toolkit::Ruler::RulerType result;
88418
88419   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88420   {
88421     try {
88422       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
88423     } catch (std::out_of_range& e) {
88424       {
88425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88426       };
88427     } catch (std::exception& e) {
88428       {
88429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88430       };
88431     } catch (...) {
88432       {
88433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88434       };
88435     }
88436   }
88437   jresult = (int)result;
88438   return jresult;
88439 }
88440
88441
88442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
88443   unsigned int jresult ;
88444   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88445   bool result;
88446
88447   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88448   {
88449     try {
88450       result = (bool)(*arg1)->IsEnabled();
88451     } catch (std::out_of_range& e) {
88452       {
88453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88454       };
88455     } catch (std::exception& e) {
88456       {
88457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88458       };
88459     } catch (...) {
88460       {
88461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88462       };
88463     }
88464   }
88465   jresult = result;
88466   return jresult;
88467 }
88468
88469
88470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
88471   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88472
88473   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88474   {
88475     try {
88476       (*arg1)->Enable();
88477     } catch (std::out_of_range& e) {
88478       {
88479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88480       };
88481     } catch (std::exception& e) {
88482       {
88483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88484       };
88485     } catch (...) {
88486       {
88487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88488       };
88489     }
88490   }
88491 }
88492
88493
88494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
88495   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88496
88497   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88498   {
88499     try {
88500       (*arg1)->Disable();
88501     } catch (std::out_of_range& e) {
88502       {
88503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88504       };
88505     } catch (std::exception& e) {
88506       {
88507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88508       };
88509     } catch (...) {
88510       {
88511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88512       };
88513     }
88514   }
88515 }
88516
88517
88518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
88519   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88520   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
88521   Dali::Toolkit::RulerDomain *argp2 ;
88522
88523   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88524   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
88525   if (!argp2) {
88526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
88527     return ;
88528   }
88529   arg2 = *argp2;
88530   {
88531     try {
88532       (*arg1)->SetDomain(arg2);
88533     } catch (std::out_of_range& e) {
88534       {
88535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88536       };
88537     } catch (std::exception& e) {
88538       {
88539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88540       };
88541     } catch (...) {
88542       {
88543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88544       };
88545     }
88546   }
88547 }
88548
88549
88550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
88551   void * jresult ;
88552   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88553   Dali::Toolkit::RulerDomain *result = 0 ;
88554
88555   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88556   {
88557     try {
88558       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
88559     } catch (std::out_of_range& e) {
88560       {
88561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88562       };
88563     } catch (std::exception& e) {
88564       {
88565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88566       };
88567     } catch (...) {
88568       {
88569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88570       };
88571     }
88572   }
88573   jresult = (void *)result;
88574   return jresult;
88575 }
88576
88577
88578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
88579   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88580
88581   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88582   {
88583     try {
88584       (*arg1)->DisableDomain();
88585     } catch (std::out_of_range& e) {
88586       {
88587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88588       };
88589     } catch (std::exception& e) {
88590       {
88591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88592       };
88593     } catch (...) {
88594       {
88595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88596       };
88597     }
88598   }
88599 }
88600
88601
88602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
88603   float jresult ;
88604   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88605   float arg2 ;
88606   float arg3 ;
88607   float arg4 ;
88608   float result;
88609
88610   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88611   arg2 = (float)jarg2;
88612   arg3 = (float)jarg3;
88613   arg4 = (float)jarg4;
88614   {
88615     try {
88616       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
88617     } catch (std::out_of_range& e) {
88618       {
88619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88620       };
88621     } catch (std::exception& e) {
88622       {
88623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88624       };
88625     } catch (...) {
88626       {
88627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88628       };
88629     }
88630   }
88631   jresult = result;
88632   return jresult;
88633 }
88634
88635
88636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
88637   float jresult ;
88638   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88639   float arg2 ;
88640   float arg3 ;
88641   float result;
88642
88643   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88644   arg2 = (float)jarg2;
88645   arg3 = (float)jarg3;
88646   {
88647     try {
88648       result = (float)(*arg1)->Clamp(arg2,arg3);
88649     } catch (std::out_of_range& e) {
88650       {
88651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88652       };
88653     } catch (std::exception& e) {
88654       {
88655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88656       };
88657     } catch (...) {
88658       {
88659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88660       };
88661     }
88662   }
88663   jresult = result;
88664   return jresult;
88665 }
88666
88667
88668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
88669   float jresult ;
88670   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88671   float arg2 ;
88672   float result;
88673
88674   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88675   arg2 = (float)jarg2;
88676   {
88677     try {
88678       result = (float)(*arg1)->Clamp(arg2);
88679     } catch (std::out_of_range& e) {
88680       {
88681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88682       };
88683     } catch (std::exception& e) {
88684       {
88685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88686       };
88687     } catch (...) {
88688       {
88689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88690       };
88691     }
88692   }
88693   jresult = result;
88694   return jresult;
88695 }
88696
88697
88698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
88699   float jresult ;
88700   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88701   float arg2 ;
88702   float arg3 ;
88703   float arg4 ;
88704   Dali::Toolkit::ClampState *arg5 = 0 ;
88705   float result;
88706
88707   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88708   arg2 = (float)jarg2;
88709   arg3 = (float)jarg3;
88710   arg4 = (float)jarg4;
88711   arg5 = (Dali::Toolkit::ClampState *)jarg5;
88712   if (!arg5) {
88713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
88714     return 0;
88715   }
88716   {
88717     try {
88718       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
88719     } catch (std::out_of_range& e) {
88720       {
88721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88722       };
88723     } catch (std::exception& e) {
88724       {
88725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88726       };
88727     } catch (...) {
88728       {
88729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88730       };
88731     }
88732   }
88733   jresult = result;
88734   return jresult;
88735 }
88736
88737
88738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
88739   float jresult ;
88740   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88741   float arg2 ;
88742   float arg3 ;
88743   float arg4 ;
88744   float arg5 ;
88745   float result;
88746
88747   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88748   arg2 = (float)jarg2;
88749   arg3 = (float)jarg3;
88750   arg4 = (float)jarg4;
88751   arg5 = (float)jarg5;
88752   {
88753     try {
88754       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
88755     } catch (std::out_of_range& e) {
88756       {
88757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88758       };
88759     } catch (std::exception& e) {
88760       {
88761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88762       };
88763     } catch (...) {
88764       {
88765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88766       };
88767     }
88768   }
88769   jresult = result;
88770   return jresult;
88771 }
88772
88773
88774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
88775   float jresult ;
88776   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88777   float arg2 ;
88778   float arg3 ;
88779   float arg4 ;
88780   float result;
88781
88782   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88783   arg2 = (float)jarg2;
88784   arg3 = (float)jarg3;
88785   arg4 = (float)jarg4;
88786   {
88787     try {
88788       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
88789     } catch (std::out_of_range& e) {
88790       {
88791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88792       };
88793     } catch (std::exception& e) {
88794       {
88795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88796       };
88797     } catch (...) {
88798       {
88799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88800       };
88801     }
88802   }
88803   jresult = result;
88804   return jresult;
88805 }
88806
88807
88808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
88809   float jresult ;
88810   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88811   float arg2 ;
88812   float arg3 ;
88813   float result;
88814
88815   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88816   arg2 = (float)jarg2;
88817   arg3 = (float)jarg3;
88818   {
88819     try {
88820       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
88821     } catch (std::out_of_range& e) {
88822       {
88823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88824       };
88825     } catch (std::exception& e) {
88826       {
88827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88828       };
88829     } catch (...) {
88830       {
88831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88832       };
88833     }
88834   }
88835   jresult = result;
88836   return jresult;
88837 }
88838
88839
88840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
88841   float jresult ;
88842   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88843   float arg2 ;
88844   float result;
88845
88846   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88847   arg2 = (float)jarg2;
88848   {
88849     try {
88850       result = (float)(*arg1)->SnapAndClamp(arg2);
88851     } catch (std::out_of_range& e) {
88852       {
88853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88854       };
88855     } catch (std::exception& e) {
88856       {
88857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88858       };
88859     } catch (...) {
88860       {
88861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88862       };
88863     }
88864   }
88865   jresult = result;
88866   return jresult;
88867 }
88868
88869
88870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
88871   float jresult ;
88872   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88873   float arg2 ;
88874   float arg3 ;
88875   float arg4 ;
88876   float arg5 ;
88877   Dali::Toolkit::ClampState *arg6 = 0 ;
88878   float result;
88879
88880   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88881   arg2 = (float)jarg2;
88882   arg3 = (float)jarg3;
88883   arg4 = (float)jarg4;
88884   arg5 = (float)jarg5;
88885   arg6 = (Dali::Toolkit::ClampState *)jarg6;
88886   if (!arg6) {
88887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
88888     return 0;
88889   }
88890   {
88891     try {
88892       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
88893     } catch (std::out_of_range& e) {
88894       {
88895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88896       };
88897     } catch (std::exception& e) {
88898       {
88899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88900       };
88901     } catch (...) {
88902       {
88903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88904       };
88905     }
88906   }
88907   jresult = result;
88908   return jresult;
88909 }
88910
88911
88912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
88913   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88914
88915   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88916   {
88917     try {
88918       (*arg1)->Reference();
88919     } catch (std::out_of_range& e) {
88920       {
88921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88922       };
88923     } catch (std::exception& e) {
88924       {
88925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88926       };
88927     } catch (...) {
88928       {
88929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88930       };
88931     }
88932   }
88933 }
88934
88935
88936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
88937   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88938
88939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88940   {
88941     try {
88942       (*arg1)->Unreference();
88943     } catch (std::out_of_range& e) {
88944       {
88945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88946       };
88947     } catch (std::exception& e) {
88948       {
88949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88950       };
88951     } catch (...) {
88952       {
88953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88954       };
88955     }
88956   }
88957 }
88958
88959
88960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
88961   int jresult ;
88962   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88963   int result;
88964
88965   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88966   {
88967     try {
88968       result = (int)(*arg1)->ReferenceCount();
88969     } catch (std::out_of_range& e) {
88970       {
88971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88972       };
88973     } catch (std::exception& e) {
88974       {
88975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88976       };
88977     } catch (...) {
88978       {
88979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88980       };
88981     }
88982   }
88983   jresult = result;
88984   return jresult;
88985 }
88986
88987
88988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
88989   unsigned int jresult ;
88990   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
88991   bool result;
88992
88993   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
88994   {
88995     try {
88996       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
88997     } catch (std::out_of_range& e) {
88998       {
88999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89000       };
89001     } catch (std::exception& e) {
89002       {
89003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89004       };
89005     } catch (...) {
89006       {
89007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89008       };
89009     }
89010   }
89011   jresult = result;
89012   return jresult;
89013 }
89014
89015
89016 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
89017   unsigned long jresult ;
89018   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89019   std::size_t result;
89020
89021   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89022   {
89023     try {
89024       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
89025     } catch (std::out_of_range& e) {
89026       {
89027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89028       };
89029     } catch (std::exception& e) {
89030       {
89031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89032       };
89033     } catch (...) {
89034       {
89035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89036       };
89037     }
89038   }
89039   jresult = (unsigned long)result;
89040   return jresult;
89041 }
89042
89043
89044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
89045   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89046   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
89047
89048   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89049   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
89050   {
89051     try {
89052       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
89053     } catch (std::out_of_range& e) {
89054       {
89055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89056       };
89057     } catch (std::exception& e) {
89058       {
89059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89060       };
89061     } catch (...) {
89062       {
89063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89064       };
89065     }
89066   }
89067 }
89068
89069
89070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
89071   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89072   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
89073
89074   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89075   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
89076   {
89077     try {
89078       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
89079     } catch (std::out_of_range& e) {
89080       {
89081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89082       };
89083     } catch (std::exception& e) {
89084       {
89085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89086       };
89087     } catch (...) {
89088       {
89089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89090       };
89091     }
89092   }
89093 }
89094
89095
89096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
89097   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89098   Dali::Toolkit::Control arg2 ;
89099   Dali::Toolkit::Control *argp2 ;
89100
89101   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89102   argp2 = (Dali::Toolkit::Control *)jarg2;
89103   if (!argp2) {
89104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
89105     return ;
89106   }
89107   arg2 = *argp2;
89108   {
89109     try {
89110       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
89111     } catch (std::out_of_range& e) {
89112       {
89113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89114       };
89115     } catch (std::exception& e) {
89116       {
89117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89118       };
89119     } catch (...) {
89120       {
89121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89122       };
89123     }
89124   }
89125 }
89126
89127
89128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
89129   void * jresult ;
89130   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
89131
89132   {
89133     try {
89134       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
89135     } catch (std::out_of_range& e) {
89136       {
89137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89138       };
89139     } catch (std::exception& e) {
89140       {
89141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89142       };
89143     } catch (...) {
89144       {
89145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89146       };
89147     }
89148   }
89149   jresult = (void *)result;
89150   return jresult;
89151 }
89152
89153
89154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
89155   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89156
89157   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89158   {
89159     try {
89160       delete arg1;
89161     } catch (std::out_of_range& e) {
89162       {
89163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89164       };
89165     } catch (std::exception& e) {
89166       {
89167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89168       };
89169     } catch (...) {
89170       {
89171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89172       };
89173     }
89174   }
89175 }
89176
89177 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
89178   Dali::RefObject *result = NULL;
89179
89180   if (arg1)
89181   {
89182     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
89183   }
89184   return result;
89185 }
89186
89187 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
89188     return (Dali::RefObject *)jarg1;
89189 }
89190
89191 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
89192     return (Dali::SignalObserver *)jarg1;
89193 }
89194
89195 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
89196     return (Dali::ConnectionTrackerInterface *)jarg1;
89197 }
89198
89199 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
89200     return (Dali::BaseHandle *)jarg1;
89201 }
89202
89203 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
89204     return (Dali::BaseHandle *)jarg1;
89205 }
89206
89207 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
89208     return (Dali::BaseHandle *)jarg1;
89209 }
89210
89211 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
89212     return (Dali::BaseHandle *)jarg1;
89213 }
89214
89215 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
89216     return (Dali::BaseHandle *)jarg1;
89217 }
89218
89219 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
89220     return (Dali::BaseHandle *)jarg1;
89221 }
89222
89223 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
89224     return (Dali::BaseHandle *)jarg1;
89225 }
89226
89227 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
89228     return (Dali::BaseHandle *)jarg1;
89229 }
89230
89231 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
89232     return (Dali::BaseHandle *)jarg1;
89233 }
89234
89235 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
89236     return (Dali::BaseHandle *)jarg1;
89237 }
89238
89239 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
89240     return (Dali::BaseHandle *)jarg1;
89241 }
89242
89243 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
89244     return (Dali::BaseHandle *)jarg1;
89245 }
89246
89247 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
89248     return (Dali::BaseHandle *)jarg1;
89249 }
89250
89251 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
89252     return (Dali::Handle *)jarg1;
89253 }
89254
89255 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
89256     return (Dali::Handle *)jarg1;
89257 }
89258
89259 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
89260     return (Dali::BaseHandle *)jarg1;
89261 }
89262
89263 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
89264     return (Dali::BaseHandle *)jarg1;
89265 }
89266
89267 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
89268     return (Dali::Handle *)jarg1;
89269 }
89270
89271 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
89272     return (Dali::BaseHandle *)jarg1;
89273 }
89274
89275 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
89276     return (Dali::Handle *)jarg1;
89277 }
89278
89279 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
89280     return (Dali::GestureDetector *)jarg1;
89281 }
89282
89283 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
89284     return (Dali::Gesture *)jarg1;
89285 }
89286
89287 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
89288     return (Dali::Handle *)jarg1;
89289 }
89290
89291 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
89292     return (Dali::Actor *)jarg1;
89293 }
89294
89295 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
89296     return (Dali::BaseHandle *)jarg1;
89297 }
89298
89299 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
89300     return (Dali::RefObject *)jarg1;
89301 }
89302
89303 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
89304     return (Dali::Actor *)jarg1;
89305 }
89306
89307 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
89308     return (Dali::GestureDetector *)jarg1;
89309 }
89310
89311 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
89312     return (Dali::Gesture *)jarg1;
89313 }
89314
89315 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
89316     return (Dali::GestureDetector *)jarg1;
89317 }
89318
89319 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
89320     return (Dali::Gesture *)jarg1;
89321 }
89322
89323 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
89324     return (Dali::GestureDetector *)jarg1;
89325 }
89326
89327 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
89328     return (Dali::Gesture *)jarg1;
89329 }
89330
89331 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
89332     return (Dali::BaseHandle *)jarg1;
89333 }
89334
89335 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
89336     return (Dali::Handle *)jarg1;
89337 }
89338
89339 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
89340     return (Dali::BaseHandle *)jarg1;
89341 }
89342
89343 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
89344     return (Dali::Handle *)jarg1;
89345 }
89346
89347 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
89348     return (Dali::Handle *)jarg1;
89349 }
89350
89351 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
89352     return (Dali::Image *)jarg1;
89353 }
89354
89355 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
89356     return (Dali::Image *)jarg1;
89357 }
89358
89359 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
89360     return (Dali::Image *)jarg1;
89361 }
89362
89363 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
89364     return (Dali::RefObject *)jarg1;
89365 }
89366
89367 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
89368     return (Dali::Image *)jarg1;
89369 }
89370
89371 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
89372     return (Dali::Image *)jarg1;
89373 }
89374
89375 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
89376     return (Dali::ResourceImage *)jarg1;
89377 }
89378
89379 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
89380     return (Dali::Actor *)jarg1;
89381 }
89382
89383 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
89384     return (Dali::BaseHandle *)jarg1;
89385 }
89386
89387 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
89388     return (Dali::BaseHandle *)jarg1;
89389 }
89390
89391
89392 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
89393     return (Dali::BaseHandle *)jarg1;
89394 }
89395
89396 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
89397     return (Dali::BaseHandle *)jarg1;
89398 }
89399
89400 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
89401     return (Dali::CustomActorImpl *)jarg1;
89402 }
89403
89404 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
89405     return (Dali::CustomActor *)jarg1;
89406 }
89407
89408 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
89409     return (Dali::BaseHandle *)jarg1;
89410 }
89411
89412 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
89413     return (Dali::Toolkit::Control *)jarg1;
89414 }
89415
89416 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
89417     return (Dali::Toolkit::Control *)jarg1;
89418 }
89419
89420 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
89421     return (Dali::Toolkit::Button *)jarg1;
89422 }
89423
89424 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
89425     return (Dali::Toolkit::Button *)jarg1;
89426 }
89427
89428 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
89429     return (Dali::Toolkit::Button *)jarg1;
89430 }
89431
89432 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
89433     return (Dali::Toolkit::Control *)jarg1;
89434 }
89435
89436 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
89437     return (Dali::Toolkit::Control *)jarg1;
89438 }
89439
89440 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
89441     return (Dali::Toolkit::Control *)jarg1;
89442 }
89443
89444 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
89445     return (Dali::Toolkit::Control *)jarg1;
89446 }
89447
89448 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
89449     return (Dali::Toolkit::Control *)jarg1;
89450 }
89451
89452 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
89453     return (Dali::RefObject *)jarg1;
89454 }
89455
89456 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
89457     return (Dali::Toolkit::Scrollable *)jarg1;
89458 }
89459
89460 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
89461     return (Dali::BaseHandle *)jarg1;
89462 }
89463
89464 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
89465     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
89466 }
89467
89468 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
89469     return (Dali::RefObject *)jarg1;
89470 }
89471
89472 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
89473     return (Dali::Toolkit::Ruler *)jarg1;
89474 }
89475
89476 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
89477     return (Dali::Toolkit::Ruler *)jarg1;
89478 }
89479
89480 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
89481     return (Dali::Toolkit::Scrollable *)jarg1;
89482 }
89483
89484 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
89485     return (Dali::Toolkit::Control *)jarg1;
89486 }
89487
89488
89489 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
89490     return (Dali::Toolkit::Control *)jarg1;
89491 }
89492
89493 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
89494     return (Dali::BaseHandle *)jarg1;
89495 }
89496
89497 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
89498     return (Dali::BaseHandle *)jarg1;
89499 }
89500
89501 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
89502     return (Dali::Toolkit::Control *)jarg1;
89503 }
89504
89505 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
89506     return (Dali::Toolkit::Control *)jarg1;
89507 }
89508
89509 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
89510     return (Dali::Toolkit::Control *)jarg1;
89511 }
89512
89513 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
89514     return (Dali::Toolkit::Control *)jarg1;
89515 }
89516
89517 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
89518     return (Dali::Toolkit::Control *)jarg1;
89519 }
89520
89521 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
89522     return (Dali::Toolkit::Control *)jarg1;
89523 }
89524
89525 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
89526     return (Dali::Toolkit::PageTurnView *)jarg1;
89527 }
89528
89529 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
89530     return (Dali::Toolkit::PageTurnView *)jarg1;
89531 }
89532
89533 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
89534     return (Dali::Toolkit::Button *)jarg1;
89535 }
89536
89537 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
89538     return (Dali::BaseHandle *)jarg1;
89539 }
89540
89541 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
89542     return (Dali::BaseHandle *)jarg1;
89543 }
89544
89545 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
89546     return (Dali::BaseHandle *)jarg1;
89547 }
89548
89549
89550
89551
89552
89553 //////////////////////////////////////////////////
89554 //from dali-swig autogeneration (from dali_wrap.cpp)
89555
89556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
89557   void * jresult ;
89558   Dali::ImfManager::ImfEventData *result = 0 ;
89559
89560   {
89561     try {
89562       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
89563     } catch (std::out_of_range& e) {
89564       {
89565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89566       };
89567     } catch (std::exception& e) {
89568       {
89569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89570       };
89571     } catch (...) {
89572       {
89573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89574       };
89575     }
89576   }
89577   jresult = (void *)result;
89578   return jresult;
89579 }
89580
89581
89582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
89583   void * jresult ;
89584   Dali::ImfManager::ImfEvent arg1 ;
89585   std::string *arg2 = 0 ;
89586   int arg3 ;
89587   int arg4 ;
89588   Dali::ImfManager::ImfEventData *result = 0 ;
89589
89590   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
89591   if (!jarg2) {
89592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89593     return 0;
89594   }
89595   std::string arg2_str(jarg2);
89596   arg2 = &arg2_str;
89597   arg3 = (int)jarg3;
89598   arg4 = (int)jarg4;
89599   {
89600     try {
89601       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
89602     } catch (std::out_of_range& e) {
89603       {
89604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89605       };
89606     } catch (std::exception& e) {
89607       {
89608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89609       };
89610     } catch (...) {
89611       {
89612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89613       };
89614     }
89615   }
89616   jresult = (void *)result;
89617
89618   //argout typemap for const std::string&
89619
89620   return jresult;
89621 }
89622
89623
89624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
89625   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89626   std::string *arg2 = 0 ;
89627
89628   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89629   if (!jarg2) {
89630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89631     return ;
89632   }
89633   std::string arg2_str(jarg2);
89634   arg2 = &arg2_str;
89635   if (arg1) (arg1)->predictiveString = *arg2;
89636
89637   //argout typemap for const std::string&
89638
89639 }
89640
89641
89642 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
89643   char * jresult ;
89644   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89645   std::string *result = 0 ;
89646
89647   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89648   result = (std::string *) & ((arg1)->predictiveString);
89649   jresult = SWIG_csharp_string_callback(result->c_str());
89650   return jresult;
89651 }
89652
89653
89654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
89655   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89656   Dali::ImfManager::ImfEvent arg2 ;
89657
89658   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89659   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
89660   if (arg1) (arg1)->eventName = arg2;
89661 }
89662
89663
89664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
89665   int jresult ;
89666   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89667   Dali::ImfManager::ImfEvent result;
89668
89669   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89670   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
89671   jresult = (int)result;
89672   return jresult;
89673 }
89674
89675
89676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
89677   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89678   int arg2 ;
89679
89680   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89681   arg2 = (int)jarg2;
89682   if (arg1) (arg1)->cursorOffset = arg2;
89683 }
89684
89685
89686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
89687   int jresult ;
89688   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89689   int result;
89690
89691   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89692   result = (int) ((arg1)->cursorOffset);
89693   jresult = result;
89694   return jresult;
89695 }
89696
89697
89698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
89699   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89700   int arg2 ;
89701
89702   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89703   arg2 = (int)jarg2;
89704   if (arg1) (arg1)->numberOfChars = arg2;
89705 }
89706
89707
89708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
89709   int jresult ;
89710   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89711   int result;
89712
89713   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89714   result = (int) ((arg1)->numberOfChars);
89715   jresult = result;
89716   return jresult;
89717 }
89718
89719
89720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
89721   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
89722
89723   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
89724   {
89725     try {
89726       delete arg1;
89727     } catch (std::out_of_range& e) {
89728       {
89729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89730       };
89731     } catch (std::exception& e) {
89732       {
89733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89734       };
89735     } catch (...) {
89736       {
89737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89738       };
89739     }
89740   }
89741 }
89742
89743
89744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
89745   void * jresult ;
89746   Dali::ImfManager::ImfCallbackData *result = 0 ;
89747
89748   {
89749     try {
89750       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
89751     } catch (std::out_of_range& e) {
89752       {
89753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89754       };
89755     } catch (std::exception& e) {
89756       {
89757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89758       };
89759     } catch (...) {
89760       {
89761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89762       };
89763     }
89764   }
89765   jresult = (void *)result;
89766   return jresult;
89767 }
89768
89769
89770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
89771   void * jresult ;
89772   bool arg1 ;
89773   int arg2 ;
89774   std::string *arg3 = 0 ;
89775   bool arg4 ;
89776   Dali::ImfManager::ImfCallbackData *result = 0 ;
89777
89778   arg1 = jarg1 ? true : false;
89779   arg2 = (int)jarg2;
89780   if (!jarg3) {
89781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89782     return 0;
89783   }
89784   std::string arg3_str(jarg3);
89785   arg3 = &arg3_str;
89786   arg4 = jarg4 ? true : false;
89787   {
89788     try {
89789       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
89790     } catch (std::out_of_range& e) {
89791       {
89792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89793       };
89794     } catch (std::exception& e) {
89795       {
89796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89797       };
89798     } catch (...) {
89799       {
89800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89801       };
89802     }
89803   }
89804   jresult = (void *)result;
89805
89806   //argout typemap for const std::string&
89807
89808   return jresult;
89809 }
89810
89811
89812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
89813   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89814   std::string *arg2 = 0 ;
89815
89816   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89817   if (!jarg2) {
89818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89819     return ;
89820   }
89821   std::string arg2_str(jarg2);
89822   arg2 = &arg2_str;
89823   if (arg1) (arg1)->currentText = *arg2;
89824
89825   //argout typemap for const std::string&
89826
89827 }
89828
89829
89830 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
89831   char * jresult ;
89832   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89833   std::string *result = 0 ;
89834
89835   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89836   result = (std::string *) & ((arg1)->currentText);
89837   jresult = SWIG_csharp_string_callback(result->c_str());
89838   return jresult;
89839 }
89840
89841
89842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
89843   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89844   int arg2 ;
89845
89846   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89847   arg2 = (int)jarg2;
89848   if (arg1) (arg1)->cursorPosition = arg2;
89849 }
89850
89851
89852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
89853   int jresult ;
89854   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89855   int result;
89856
89857   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89858   result = (int) ((arg1)->cursorPosition);
89859   jresult = result;
89860   return jresult;
89861 }
89862
89863
89864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
89865   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89866   bool arg2 ;
89867
89868   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89869   arg2 = jarg2 ? true : false;
89870   if (arg1) (arg1)->update = arg2;
89871 }
89872
89873
89874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
89875   unsigned int jresult ;
89876   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89877   bool result;
89878
89879   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89880   result = (bool) ((arg1)->update);
89881   jresult = result;
89882   return jresult;
89883 }
89884
89885
89886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
89887   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89888   bool arg2 ;
89889
89890   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89891   arg2 = jarg2 ? true : false;
89892   if (arg1) (arg1)->preeditResetRequired = arg2;
89893 }
89894
89895
89896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
89897   unsigned int jresult ;
89898   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89899   bool result;
89900
89901   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89902   result = (bool) ((arg1)->preeditResetRequired);
89903   jresult = result;
89904   return jresult;
89905 }
89906
89907
89908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
89909   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
89910
89911   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
89912   {
89913     try {
89914       delete arg1;
89915     } catch (std::out_of_range& e) {
89916       {
89917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89918       };
89919     } catch (std::exception& e) {
89920       {
89921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89922       };
89923     } catch (...) {
89924       {
89925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89926       };
89927     }
89928   }
89929 }
89930
89931
89932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
89933   void * jresult ;
89934   Dali::ImfManager result;
89935
89936   {
89937     try {
89938       result = Dali::ImfManager::Get();
89939     } catch (std::out_of_range& e) {
89940       {
89941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89942       };
89943     } catch (std::exception& e) {
89944       {
89945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89946       };
89947     } catch (...) {
89948       {
89949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89950       };
89951     }
89952   }
89953   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
89954   return jresult;
89955 }
89956
89957
89958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
89959   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
89960
89961   arg1 = (Dali::ImfManager *)jarg1;
89962   {
89963     try {
89964       (arg1)->Activate();
89965     } catch (std::out_of_range& e) {
89966       {
89967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89968       };
89969     } catch (std::exception& e) {
89970       {
89971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89972       };
89973     } catch (...) {
89974       {
89975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89976       };
89977     }
89978   }
89979 }
89980
89981
89982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
89983   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
89984
89985   arg1 = (Dali::ImfManager *)jarg1;
89986   {
89987     try {
89988       (arg1)->Deactivate();
89989     } catch (std::out_of_range& e) {
89990       {
89991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89992       };
89993     } catch (std::exception& e) {
89994       {
89995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89996       };
89997     } catch (...) {
89998       {
89999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90000       };
90001     }
90002   }
90003 }
90004
90005
90006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
90007   unsigned int jresult ;
90008   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90009   bool result;
90010
90011   arg1 = (Dali::ImfManager *)jarg1;
90012   {
90013     try {
90014       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
90015     } catch (std::out_of_range& e) {
90016       {
90017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90018       };
90019     } catch (std::exception& e) {
90020       {
90021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90022       };
90023     } catch (...) {
90024       {
90025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90026       };
90027     }
90028   }
90029   jresult = result;
90030   return jresult;
90031 }
90032
90033
90034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
90035   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90036   bool arg2 ;
90037
90038   arg1 = (Dali::ImfManager *)jarg1;
90039   arg2 = jarg2 ? true : false;
90040   {
90041     try {
90042       (arg1)->SetRestoreAfterFocusLost(arg2);
90043     } catch (std::out_of_range& e) {
90044       {
90045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90046       };
90047     } catch (std::exception& e) {
90048       {
90049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90050       };
90051     } catch (...) {
90052       {
90053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90054       };
90055     }
90056   }
90057 }
90058
90059
90060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
90061   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90062
90063   arg1 = (Dali::ImfManager *)jarg1;
90064   {
90065     try {
90066       (arg1)->Reset();
90067     } catch (std::out_of_range& e) {
90068       {
90069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90070       };
90071     } catch (std::exception& e) {
90072       {
90073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90074       };
90075     } catch (...) {
90076       {
90077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90078       };
90079     }
90080   }
90081 }
90082
90083
90084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
90085   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90086
90087   arg1 = (Dali::ImfManager *)jarg1;
90088   {
90089     try {
90090       (arg1)->NotifyCursorPosition();
90091     } catch (std::out_of_range& e) {
90092       {
90093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90094       };
90095     } catch (std::exception& e) {
90096       {
90097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90098       };
90099     } catch (...) {
90100       {
90101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90102       };
90103     }
90104   }
90105 }
90106
90107
90108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
90109   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90110   unsigned int arg2 ;
90111
90112   arg1 = (Dali::ImfManager *)jarg1;
90113   arg2 = (unsigned int)jarg2;
90114   {
90115     try {
90116       (arg1)->SetCursorPosition(arg2);
90117     } catch (std::out_of_range& e) {
90118       {
90119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90120       };
90121     } catch (std::exception& e) {
90122       {
90123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90124       };
90125     } catch (...) {
90126       {
90127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90128       };
90129     }
90130   }
90131 }
90132
90133
90134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
90135   unsigned int jresult ;
90136   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90137   unsigned int result;
90138
90139   arg1 = (Dali::ImfManager *)jarg1;
90140   {
90141     try {
90142       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
90143     } catch (std::out_of_range& e) {
90144       {
90145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90146       };
90147     } catch (std::exception& e) {
90148       {
90149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90150       };
90151     } catch (...) {
90152       {
90153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90154       };
90155     }
90156   }
90157   jresult = result;
90158   return jresult;
90159 }
90160
90161
90162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
90163   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90164   std::string *arg2 = 0 ;
90165
90166   arg1 = (Dali::ImfManager *)jarg1;
90167   if (!jarg2) {
90168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90169     return ;
90170   }
90171   std::string arg2_str(jarg2);
90172   arg2 = &arg2_str;
90173   {
90174     try {
90175       (arg1)->SetSurroundingText((std::string const &)*arg2);
90176     } catch (std::out_of_range& e) {
90177       {
90178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90179       };
90180     } catch (std::exception& e) {
90181       {
90182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90183       };
90184     } catch (...) {
90185       {
90186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90187       };
90188     }
90189   }
90190
90191   //argout typemap for const std::string&
90192
90193 }
90194
90195
90196 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
90197   char * jresult ;
90198   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90199   std::string *result = 0 ;
90200
90201   arg1 = (Dali::ImfManager *)jarg1;
90202   {
90203     try {
90204       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
90205     } catch (std::out_of_range& e) {
90206       {
90207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90208       };
90209     } catch (std::exception& e) {
90210       {
90211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (...) {
90214       {
90215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90216       };
90217     }
90218   }
90219   jresult = SWIG_csharp_string_callback(result->c_str());
90220   return jresult;
90221 }
90222
90223
90224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
90225   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90226   bool arg2 ;
90227
90228   arg1 = (Dali::ImfManager *)jarg1;
90229   arg2 = jarg2 ? true : false;
90230   {
90231     try {
90232       (arg1)->NotifyTextInputMultiLine(arg2);
90233     } catch (std::out_of_range& e) {
90234       {
90235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90236       };
90237     } catch (std::exception& e) {
90238       {
90239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90240       };
90241     } catch (...) {
90242       {
90243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90244       };
90245     }
90246   }
90247 }
90248
90249
90250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
90251   int jresult ;
90252   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90253   Dali::ImfManager::TextDirection result;
90254
90255   arg1 = (Dali::ImfManager *)jarg1;
90256   {
90257     try {
90258       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
90259     } catch (std::out_of_range& e) {
90260       {
90261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90262       };
90263     } catch (std::exception& e) {
90264       {
90265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90266       };
90267     } catch (...) {
90268       {
90269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90270       };
90271     }
90272   }
90273   jresult = (int)result;
90274   return jresult;
90275 }
90276
90277
90278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
90279   void * jresult ;
90280   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90281   Dali::Rect< int > result;
90282
90283   arg1 = (Dali::ImfManager *)jarg1;
90284   {
90285     try {
90286       result = (arg1)->GetInputMethodArea();
90287     } catch (std::out_of_range& e) {
90288       {
90289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90290       };
90291     } catch (std::exception& e) {
90292       {
90293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90294       };
90295     } catch (...) {
90296       {
90297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90298       };
90299     }
90300   }
90301   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
90302   return jresult;
90303 }
90304
90305
90306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
90307   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90308   Dali::InputMethodOptions *arg2 = 0 ;
90309
90310   arg1 = (Dali::ImfManager *)jarg1;
90311   arg2 = (Dali::InputMethodOptions *)jarg2;
90312   if (!arg2) {
90313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
90314     return ;
90315   }
90316   {
90317     try {
90318       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
90319     } catch (std::out_of_range& e) {
90320       {
90321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90322       };
90323     } catch (std::exception& e) {
90324       {
90325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90326       };
90327     } catch (...) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90330       };
90331     }
90332   }
90333 }
90334
90335
90336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
90337   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90338   std::string *arg2 = 0 ;
90339
90340   arg1 = (Dali::ImfManager *)jarg1;
90341   if (!jarg2) {
90342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90343     return ;
90344   }
90345   std::string arg2_str(jarg2);
90346   arg2 = &arg2_str;
90347   {
90348     try {
90349       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
90350     } catch (std::out_of_range& e) {
90351       {
90352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90353       };
90354     } catch (std::exception& e) {
90355       {
90356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90357       };
90358     } catch (...) {
90359       {
90360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90361       };
90362     }
90363   }
90364
90365   //argout typemap for const std::string&
90366
90367 }
90368
90369
90370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
90371   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90372   std::string *arg2 = 0 ;
90373
90374   arg1 = (Dali::ImfManager *)jarg1;
90375   if (!jarg2) {
90376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90377     return ;
90378   }
90379   std::string arg2_str(jarg2);
90380   arg2 = &arg2_str;
90381   {
90382     try {
90383       (arg1)->GetInputPanelUserData((std::string &)*arg2);
90384     } catch (std::out_of_range& e) {
90385       {
90386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90387       };
90388     } catch (std::exception& e) {
90389       {
90390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90391       };
90392     } catch (...) {
90393       {
90394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90395       };
90396     }
90397   }
90398
90399 }
90400
90401
90402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
90403   int jresult ;
90404   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90405   Dali::ImfManager::State result;
90406
90407   arg1 = (Dali::ImfManager *)jarg1;
90408   {
90409     try {
90410       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
90411     } catch (std::out_of_range& e) {
90412       {
90413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90414       };
90415     } catch (std::exception& e) {
90416       {
90417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90418       };
90419     } catch (...) {
90420       {
90421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90422       };
90423     }
90424   }
90425   jresult = (int)result;
90426   return jresult;
90427 }
90428
90429
90430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
90431   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90432   bool arg2 ;
90433
90434   arg1 = (Dali::ImfManager *)jarg1;
90435   arg2 = jarg2 ? true : false;
90436   {
90437     try {
90438       (arg1)->SetReturnKeyState(arg2);
90439     } catch (std::out_of_range& e) {
90440       {
90441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90442       };
90443     } catch (std::exception& e) {
90444       {
90445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90446       };
90447     } catch (...) {
90448       {
90449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90450       };
90451     }
90452   }
90453 }
90454
90455
90456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
90457   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90458   bool arg2 ;
90459
90460   arg1 = (Dali::ImfManager *)jarg1;
90461   arg2 = jarg2 ? true : false;
90462   {
90463     try {
90464       (arg1)->AutoEnableInputPanel(arg2);
90465     } catch (std::out_of_range& e) {
90466       {
90467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90468       };
90469     } catch (std::exception& e) {
90470       {
90471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90472       };
90473     } catch (...) {
90474       {
90475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90476       };
90477     }
90478   }
90479 }
90480
90481
90482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
90483   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90484
90485   arg1 = (Dali::ImfManager *)jarg1;
90486   {
90487     try {
90488       (arg1)->ShowInputPanel();
90489     } catch (std::out_of_range& e) {
90490       {
90491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90492       };
90493     } catch (std::exception& e) {
90494       {
90495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90496       };
90497     } catch (...) {
90498       {
90499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90500       };
90501     }
90502   }
90503 }
90504
90505
90506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
90507   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90508
90509   arg1 = (Dali::ImfManager *)jarg1;
90510   {
90511     try {
90512       (arg1)->HideInputPanel();
90513     } catch (std::out_of_range& e) {
90514       {
90515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90516       };
90517     } catch (std::exception& e) {
90518       {
90519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90520       };
90521     } catch (...) {
90522       {
90523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90524       };
90525     }
90526   }
90527 }
90528
90529
90530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
90531   void * jresult ;
90532   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90533   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
90534
90535   arg1 = (Dali::ImfManager *)jarg1;
90536   {
90537     try {
90538       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
90539     } catch (std::out_of_range& e) {
90540       {
90541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90542       };
90543     } catch (std::exception& e) {
90544       {
90545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90546       };
90547     } catch (...) {
90548       {
90549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90550       };
90551     }
90552   }
90553   jresult = (void *)result;
90554   return jresult;
90555 }
90556
90557
90558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
90559   void * jresult ;
90560   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90561   Dali::ImfManager::ImfEventSignalType *result = 0 ;
90562
90563   arg1 = (Dali::ImfManager *)jarg1;
90564   {
90565     try {
90566       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
90567     } catch (std::out_of_range& e) {
90568       {
90569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90570       };
90571     } catch (std::exception& e) {
90572       {
90573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90574       };
90575     } catch (...) {
90576       {
90577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90578       };
90579     }
90580   }
90581   jresult = (void *)result;
90582   return jresult;
90583 }
90584
90585
90586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
90587   void * jresult ;
90588   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90589   Dali::ImfManager::StatusSignalType *result = 0 ;
90590
90591   arg1 = (Dali::ImfManager *)jarg1;
90592   {
90593     try {
90594       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
90595     } catch (std::out_of_range& e) {
90596       {
90597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90598       };
90599     } catch (std::exception& e) {
90600       {
90601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90602       };
90603     } catch (...) {
90604       {
90605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90606       };
90607     }
90608   }
90609   jresult = (void *)result;
90610   return jresult;
90611 }
90612
90613
90614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
90615   void * jresult ;
90616   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90617   Dali::ImfManager::VoidSignalType *result = 0 ;
90618
90619   arg1 = (Dali::ImfManager *)jarg1;
90620   {
90621     try {
90622       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
90623     } catch (std::out_of_range& e) {
90624       {
90625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90626       };
90627     } catch (std::exception& e) {
90628       {
90629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90630       };
90631     } catch (...) {
90632       {
90633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90634       };
90635     }
90636   }
90637   jresult = (void *)result;
90638   return jresult;
90639 }
90640
90641
90642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
90643   void * jresult ;
90644   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90645   Dali::ImfManager::VoidSignalType *result = 0 ;
90646
90647   arg1 = (Dali::ImfManager *)jarg1;
90648   {
90649     try {
90650       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
90651     } catch (std::out_of_range& e) {
90652       {
90653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90654       };
90655     } catch (std::exception& e) {
90656       {
90657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90658       };
90659     } catch (...) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90662       };
90663     }
90664   }
90665   jresult = (void *)result;
90666   return jresult;
90667 }
90668
90669
90670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
90671   void * jresult ;
90672   Dali::ImfManager *result = 0 ;
90673
90674   {
90675     try {
90676       result = (Dali::ImfManager *)new Dali::ImfManager();
90677     } catch (std::out_of_range& e) {
90678       {
90679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90680       };
90681     } catch (std::exception& e) {
90682       {
90683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90684       };
90685     } catch (...) {
90686       {
90687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90688       };
90689     }
90690   }
90691   jresult = (void *)result;
90692   return jresult;
90693 }
90694
90695
90696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
90697   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
90698
90699   arg1 = (Dali::ImfManager *)jarg1;
90700   {
90701     try {
90702       delete arg1;
90703     } catch (std::out_of_range& e) {
90704       {
90705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90706       };
90707     } catch (std::exception& e) {
90708       {
90709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90710       };
90711     } catch (...) {
90712       {
90713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90714       };
90715     }
90716   }
90717 }
90718
90719
90720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
90721   void * jresult ;
90722   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
90723   Dali::ImfManager *result = 0 ;
90724
90725   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
90726   {
90727     try {
90728       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
90729     } catch (std::out_of_range& e) {
90730       {
90731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90732       };
90733     } catch (std::exception& e) {
90734       {
90735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90736       };
90737     } catch (...) {
90738       {
90739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90740       };
90741     }
90742   }
90743   jresult = (void *)result;
90744   return jresult;
90745 }
90746
90747
90748 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
90749     return (Dali::BaseHandle *)jarg1;
90750 }
90751
90752
90753 //////////////////////////////////////////////////
90754 //from dali-swig autogeneration (from dali_wrap.cpp)
90755
90756
90757
90758
90759
90760
90761
90762
90763
90764
90765
90766
90767 #ifdef __cplusplus
90768 }
90769 #endif